From 677b108640caddf892cd6712efbac3074401a4d7 Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Wed, 16 Nov 2022 10:12:06 +1100 Subject: [PATCH 1/9] cmd line opperation for F10 run F10 script via cmdline and exit see main.pas search CMDLINE_OP --- Main.ddp | Bin 0 -> 51 bytes Main.dfm | Bin 80037 -> 79903 bytes Main.pas | 43 +- Main.~ddp | Bin 0 -> 51 bytes Main.~dfm | Bin 0 -> 79903 bytes Main.~pas | 16935 ++++++++++++++++++++++++++++++++++++++++++++++++++++ ts.exe | Bin 0 -> 1067008 bytes ts.tsc | 14 + 8 files changed, 16981 insertions(+), 11 deletions(-) create mode 100644 Main.ddp create mode 100644 Main.~ddp create mode 100644 Main.~dfm create mode 100644 Main.~pas create mode 100644 ts.exe create mode 100644 ts.tsc diff --git a/Main.ddp b/Main.ddp new file mode 100644 index 0000000000000000000000000000000000000000..4370276c196a7fa73d6f8917622cba1c4e033dee GIT binary patch literal 51 zcmZRVaB=ks@bJ`g@pN<#a`e>;@DB=c^Y`)e=VxGe;K0Pl$;KI)SCUzhlbT}4#=r!G E07ZHWvj6}9 literal 0 HcmV?d00001 diff --git a/Main.dfm b/Main.dfm index 642c2093008ee41ef2a2cb374ec11fa076dbc294..3782e27e10425d89a7fb30e445195346d9253f59 100644 GIT binary patch delta 354 zcmZ4bk!Ah|7J>g<3?aUbo_=orLB0$I0z4B16gb{8F^A+AFcogJoWa5+%)}a=nNpI$ z>^%84ODv=FWJ}g=VHT*EH8Yz>YG!&y36tmM>#Y5ZK+3C_AI`W>0lZeie>@{Nl`# z%=|ni0gjNwB>$q6)FLJZ?vRYq+$5jWy!4U`CV|Pn%?ug8ZPqnktt+_^)lD*RH%g<3?aUbo_=orLB0$I0+S{RC~&ecGKb_BFyCj`XfcC@i;sylJTs*v zgV}oWEtXhD>&X_Z-NI~8F=J*nkJQZcj1ngI&DU7_8G+Ji?3a1DgEMmra#8~l^HOs- zCR=hyOCDtcnaLyz(Z^H<)yDjBb1ug(R>p^uGx&OVn0+(zm>8IS6DycfHh{qPR()6 zOJQQ*05XD05{pWJ%#g$+|Du%CA|?jzkc`sYB%jp0^pXrF0nU)jqU>UJ-jZCW z{F0LV+#pa0fF*)UD!Fn}+1W~p9ZO5{C)b!6GJf2=&TO@=M diff --git a/Main.pas b/Main.pas index f009df3..a74c491 100644 --- a/Main.pas +++ b/Main.pas @@ -1001,7 +1001,9 @@ TMainForm = class(TForm) Sessions: Integer; History: string; CDROM: Boolean; - ReadParamFile: Boolean; + ReadParamFile: Boolean;//CMDLINE_OP + resultCMD: Integer;//CMDLINE_OP + ReadParamCMD: string; RecentFiles: TStringList; WinLeft, WinTop, WinWidth, WinHeight: Integer; // 2.55 TileSelX1, TileSelY1, // 2.0 @@ -13686,16 +13688,19 @@ procedure TMainForm.Generate1Click(Sender: TObject); H := LastH; end; - - if ErrMsg <> '' then - ShowMessage (ErrMsg) - else - begin - with ProgressBar do - Position := Max; - ShowMessage ('Code generated successfully'); - end; - +// CMDLINE_OP + if ReadParamCMD <> 'F10' then + begin + if ErrMsg <> '' then + ShowMessage (ErrMsg) + else + begin + with ProgressBar do + Position := Max; + ShowMessage ('Code generated successfully'); + end; + end; +// CMDLINE_OP // clean up and release memory @@ -14742,6 +14747,22 @@ procedure TMainForm.FormShow(Sender: TObject); begin Modified := FALSE; Open1Click (nil); + //CMDLINE_OP + ReadParamFile := ParamCount > 1; + if ReadParamFile then + begin + + + ReadParamCMD := ParamStr(2); + + if ReadParamCMD = 'F10' then + begin + Generate1Click(Self); + Modified := FALSE; + Exit1Click(Self); + end; + end; + //CMDLINE_OP end; ReadParamFile := FALSE; end; diff --git a/Main.~ddp b/Main.~ddp new file mode 100644 index 0000000000000000000000000000000000000000..4370276c196a7fa73d6f8917622cba1c4e033dee GIT binary patch literal 51 zcmZRVaB=ks@bJ`g@pN<#a`e>;@DB=c^Y`)e=VxGe;K0Pl$;KI)SCUzhlbT}4#=r!G E07ZHWvj6}9 literal 0 HcmV?d00001 diff --git a/Main.~dfm b/Main.~dfm new file mode 100644 index 0000000000000000000000000000000000000000..3782e27e10425d89a7fb30e445195346d9253f59 GIT binary patch literal 79903 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 bounds ??? + + + + History: + + - added: 'remove duplicate tiles' option for import tiles to avoid 'too many tiles' error + - fixed: paste button was often disabled when trying to copy from external source + - fixed: when removing an animation sequence, the numbers of the others in the maps are now properly lowered + + + Version 3.0 + + - select next/previous clips with Ctrl+Shift+Alt Left/Right + - added Tile->Replace color under cursor (Ctrl+R) + - added (simple) onion skinning: show a vague image of a different tile while drawing a tile, + right-click on other tile (at the bottom) + - added 'text' quotes also allowed for strings in addition to "text", useful for '"' + - added option !StartWithEmptyTile + - added opacity slider (for most drawing tools) + - fixed import palette + - 256-color palette DEFAULT.PAL (F8 to switch) + - added .. + - changed PNG unit to PNGImage ??? + - RGB conversion scripts + + - #readtextfile (, , ) + - #readbinfile (, , ) + - project lists / #list <(Name)Item/Value(n)> + - added history panel for coordinates + - added (limited) .PCX support + - added , , + and in case there are no maps (now refer to last #tstilebitmap) + - added Replace Current Tile Sequence (Ctrl+Shift+F7) + - added #sequenceframe ... #end sequencframe: same as #sequencedata, but goes through + each frame n+1 times (where n is the duration of each frame) + + + + Version 2.55 + + - fixed: Edit, Replace Colors, Replace All was replacing complete tiles + - added: Quick keys 0-9 for tools + - starting a new selection in the map doesn't change the bounds anymore + - sequences can have bounds + - #sequencedata .. #end sequencedata can now contain variable + (the bounds of the tiles used to make the sequence) + - fixed + - fixed: config file not loaded when starting from other directory + - transparent color can be changed by editing the config file TS.TSC + - paste images half size + - fixed bug introduced in 2.54: #bitmapfile didn't use target directory + + + Version 2.54 + + - export separate tiles with #TILEBITMAP or #TSTILEBITMAP + - #file ...\\... now creates path + - Replace Colors - OtherFromToList + - fixed range check error when placing mirrored tile in map with 1234 tool + - View menu: show back/mid/front layer + - copy current tile combination to clipboard (to paste as new tile) + - TilesetBitmapWidth and TilesetBitmapHeight are updated directly after #TilesetBitmap + - Map grid guidelines + + + Version 2.53 + + - fixed: move tile left/right (range check error) + - added: scale down factor 1/2/4/8 for export map as image + - added: smart pattern selection / pick up pattern (Alt + RMB) + - fixed: delete tile messed up bounds + - fixed: included maps that weren't exported + - added: , , tile 0 = 1 + - fixed: TileData: N parameter - check for compatibility! + - fixed: progressbar during generate code works better now + + + Version 2.52 + + - added: replace tiles in map + - added: replace color in tile: Ctrl + fill tool + + + Version 2.51 + + - added: tile grid (Ctrl+G to enable/disable) + - fixed: exporting map as image would only export the visible region + - added: pick up several colors to make a color pattern (Ctrl + right click) + - added: used color palette shows RGB values when moving the mouse + + + Version 2.5 + - .tsd file in project directory + - added #TSTILEBITMAP keyword + - fixed access violation error (drawing small maps with overlap > 0) + - #uniquetextile + - export complete maps as images + - right-click in map selects tile + - lighting direction can be selected (shift+left mouse button on bound box) + - binary output files: #BINFILE + - tile rotation in maps (TSBackR, TSMidR, TSFrontR) + - rotate tiles right/left (tile editor) + - hide tile set panel + - show selection size in status bar + - scale down tilesets while generating code (anti-aliasing) + + + + 2.44 and before: see website + + Modified by Rainer Deyke (rainerd@eldwood.com) // 2.42 + + } + + {$I SETTINGS.INC} + + { PNG is now handled by PngImage instead of PngUnit } + + +interface + +uses + Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, + Menus, ExtCtrls, ComCtrls, StdCtrls, Grids, jpeg, ToolWin, Buttons, Tiles, + ExtDlgs, ShellAPI, ImgList, Spin, Math, Noise, SZPCX; + +const + APPL_NAME = 'Tile Studio'; + ApplPath: string = ''; + VERSION_NUMBER: string = '3.0'; + DEFAULT_NAME = 'Untitled'; + DEFAULT_EXT = '.tsp'; + URL = 'http://tilestudio.sourceforge.net/'; + OutputPath: string = ''; + pfMap = pf16bit; + pfFinal = pf24bit; + pfOutput = pf24bit; + CONFIG_FILE = 'ts.tsc'; +{$IFDEF CREATE_BACKUP_FILES} + BACKUP_EXT = '.$$$'; +{$ENDIF} + DEFAULT_PAL = 'default.pal'; + RGBCONV_FILE = 'rgbconv.txt'; + +const + Filename: string = ''; + FileToOpen: string = ''; + +const + MAX_PALETTE_ORDER = 6; + MAX_FROM_TO = 9; + DEFAULT_COLOR = $676767; + DEFAULT_BACKGR_COLOR = $AAAAAA; + BORDER_W = 5; + BORDER_H = 5; + DEFAULT_SCALE = 8; + MAX_SCALE = 16; + MAX_UNDO = 50; + DEFAULT_CURSOR_SIZE = 4; + MAX_ZOOM = 9; + ZOOM_FACTOR = 3; + DEFAULT_ANIMATION_SPEED = 500; + DEFAULT_SEQ_SPEED = 25; + LONG_LINE = 74; + +type + TileTabRec = + record + tbr: TileBitmapRec; + id: string; + lastscrollpos: Integer; + lastscale: Integer; + + AnimStart, AnimEnd: Integer; + BackGrColor: Integer; + end; + +type + UndoRec = + record + ActionName: string; + Bmp: TBitmap; + HistoryCoords: string; // 3.00 + end; + +type + TFromToList = array[0..MAX_FROM_TO - 1] of Integer; + TExFromToList = array[0..MAX_FROM_TO - 1, 0..2] of Integer; + +type + FTSaveRec = + record + FT: TFromToList; + EXFT: TExFromToList; + F, L: Integer; + + end; + +type + TEditorMode = (mTile, mMap); + +type + TDrawingTool = (dtPoint, + dtBrush, + dtLine, + dtRect, + dtRoundRect, + dtEllipse, + dtFill, + dtFilledRect, + dtFilledRoundRect, + dtFilledEllipse, + dtSelection); + + TMapDrawingTool = (mdtPoint, mdtFilledRect, + mdtZOrder, mdtRect); + +const + FirstSaveUndoTools = [dtPoint, dtBrush, dtFill]; + +function WithoutExt (Name: string; Ext: string): string; + +type + TMainForm = class(TForm) + TilePanel: TPanel; + RightPanel: TPanel; + MainMenu: TMainMenu; + File1: TMenuItem; + NewGame1: TMenuItem; + N2: TMenuItem; + Open1: TMenuItem; + Save1: TMenuItem; + SaveAs1: TMenuItem; + N1: TMenuItem; + Exit1: TMenuItem; + Edit1: TMenuItem; + Undo1: TMenuItem; + N3: TMenuItem; + Cut1: TMenuItem; + Copy1: TMenuItem; + Paste1: TMenuItem; + Delete1: TMenuItem; + View1: TMenuItem; + RearrangePalette1: TMenuItem; + ScrollBox: TScrollBox; + PalettePanel: TPanel; + ColorsPanel: TPanel; + Palette: TPaintBox; + ColorPanel: TPanel; + BackgroundPanel: TPanel; + FromToPanel: TPanel; + Color: TShape; + Background: TShape; + FromTo: TPaintBox; + ZoomIn1: TMenuItem; + ZoomOut1: TMenuItem; + Tile: TImage; + Toolbar: TToolBar; + Move1: TMenuItem; + Up1: TMenuItem; + Down1: TMenuItem; + Left1: TMenuItem; + Right1: TMenuItem; + Tile1: TMenuItem; + Flip1: TMenuItem; + Horizontal1: TMenuItem; + Vertical1: TMenuItem; + Clear1: TMenuItem; + PatternPanel: TPanel; + N5: TMenuItem; + Pattern1: TMenuItem; + Pattern: TImage; + N6: TMenuItem; + ImportTiles1: TMenuItem; + ExportTiles1: TMenuItem; + OpenPictureDialog: TOpenPictureDialog; + NewTile1: TMenuItem; + MatchColors1: TMenuItem; + Help1: TMenuItem; + About1: TMenuItem; + Redo1: TMenuItem; + N8: TMenuItem; + MoveTile1: TMenuItem; + MoveTileLeft: TMenuItem; + MoveTileRight: TMenuItem; + N9: TMenuItem; + RemoveDuplicateTiles1: TMenuItem; + Homepage1: TMenuItem; + N10: TMenuItem; + SavePictureDialog: TSavePictureDialog; + SetBounds1: TMenuItem; + Left2: TMenuItem; + Right2: TMenuItem; + Top1: TMenuItem; + Bottom1: TMenuItem; + N13: TMenuItem; + DiagonalUp1: TMenuItem; + DiagonalDown1: TMenuItem; + N12: TMenuItem; + ClearAll1: TMenuItem; + NewTileSet1: TMenuItem; + Map1: TMenuItem; + N11: TMenuItem; + Properties1: TMenuItem; + ProgressPanel: TPanel; + ProgressBar: TProgressBar; + Toolbar1: TMenuItem; + ImageList: TImageList; + NewButton: TToolButton; + OpenButton: TToolButton; + SaveButton: TToolButton; + ToolButton1: TToolButton; + CutButton: TToolButton; + CopyButton: TToolButton; + PasteButton: TToolButton; + ToolButton2: TToolButton; + UndoButton: TToolButton; + RedoButton: TToolButton; + DeleteButton: TToolButton; + ToolButton3: TToolButton; + Zoom1: TMenuItem; + ZoomButton: TToolButton; + ActualSize1: TMenuItem; + FitinWindow1: TMenuItem; + RGBColorDepth1: TMenuItem; + N61: TMenuItem; + N71: TMenuItem; + N81: TMenuItem; + N91: TMenuItem; + StatusBar: TStatusBar; + Tab: TTabControl; + TileScrollBox: TScrollBox; + TileBitmap: TImage; + ZoomInButton: TToolButton; + ZoomOutButton: TToolButton; + DuplicateTile1: TMenuItem; + N101: TMenuItem; + Palette1: TMenuItem; + N4: TMenuItem; + ColorBrightness1: TMenuItem; + N_1: TMenuItem; + N_2: TMenuItem; + N_3: TMenuItem; + N_4: TMenuItem; + N_5: TMenuItem; + N_6: TMenuItem; + N_7: TMenuItem; + N_8: TMenuItem; + N_9: TMenuItem; + ToolButton7: TToolButton; + NewTileButton: TToolButton; + ColorMatchButton: TToolButton; + ToolButton4: TToolButton; + ColorDialog: TColorDialog; + N14: TMenuItem; + Map2: TMenuItem; + BackgroundColor1: TMenuItem; + N15: TMenuItem; + CursorImage: TImage; + CurTilePanel: TPanel; + TilePartsPanel: TPanel; + CopyTiles1: TMenuItem; + InsertNewTile1: TMenuItem; + PreviousTile1: TMenuItem; + NextTile1: TMenuItem; + N16: TMenuItem; + FirstTile1: TMenuItem; + LastTile1: TMenuItem; + pBack: TPanel; + pMid: TPanel; + pFront: TPanel; + bmpBack: TImage; + bmpMid: TImage; + bmpFront: TImage; + pPreview: TPanel; + bmpPreview: TImage; + StretchPaste1: TMenuItem; + ToggleMultiple1: TMenuItem; + bUps: TSpeedButton; + mUps: TSpeedButton; + fUps: TSpeedButton; + bMir: TSpeedButton; + mMir: TSpeedButton; + fMir: TSpeedButton; + bRot: TSpeedButton; + mRot: TSpeedButton; + fRot: TSpeedButton; + FlipCurrentTile1: TMenuItem; + Horizontal2: TMenuItem; + Vertical2: TMenuItem; + SelectCurrentTile1: TMenuItem; + SelectBackMidFront1: TMenuItem; + Next1: TMenuItem; + Previous1: TMenuItem; + ToggleTileMapEditor1: TMenuItem; + LeftPanel: TPanel; + ToolPanel: TPanel; + PencilButton: TSpeedButton; + LineButton: TSpeedButton; + RectButton: TSpeedButton; + RoundRectButton: TSpeedButton; + EllipseButton: TSpeedButton; + BrushButton: TSpeedButton; + FillButton: TSpeedButton; + FilledRectButton: TSpeedButton; + FilledRoundRectButton: TSpeedButton; + FilledEllipseButton: TSpeedButton; + LightButton: TSpeedButton; + DarkButton: TSpeedButton; + PlusButton: TSpeedButton; + RandomButton: TSpeedButton; + LineToolPanel: TPanel; + LineTool: TShape; + ExtraPanel: TPanel; + BoundPanel: TPanel; + BoundBox: TPaintBox; + MapCodeButton: TSpeedButton; + MapTab: TTabControl; + MapScrollBox: TScrollBox; + MapDisplay: TPaintBox; // 2.42 + ClipTab: TTabControl; + ClipScrollBox: TScrollBox; + UsedColors: TPanel; + ShowUsedColors1: TMenuItem; + UsedColorsImage: TImage; + N18: TMenuItem; + MapProperties1: TMenuItem; + InvPanel: TPanel; + ShowGrid1: TMenuItem; + MapToolPanel: TPanel; + MapPointButton: TSpeedButton; + MapRectButton: TSpeedButton; + ShowMapCodes1: TMenuItem; + bmp1: TImage; + bmp2: TImage; + ShowBounds1: TMenuItem; + SelBmp: TImage; + ZOrderButton: TSpeedButton; + BlockButton: TSpeedButton; + N20: TMenuItem; + ClearArea1: TMenuItem; + ClipBitmap: TImage; + RandomFill1: TMenuItem; + N21: TMenuItem; + RemoveTileSet1: TMenuItem; + RemoveMap1: TMenuItem; + OpenDialog: TOpenDialog; + SaveDialog: TSaveDialog; + AnimationTimer: TTimer; + Animation1: TMenuItem; + FirstFrame1: TMenuItem; + LastFrame1: TMenuItem; + N22: TMenuItem; + NextFrame1: TMenuItem; + Animate1: TMenuItem; + PreviousFrame1: TMenuItem; + N23: TMenuItem; + Faster1: TMenuItem; + Slower1: TMenuItem; + AnimationSpeed1: TMenuItem; + Default1: TMenuItem; + TileModeButton: TToolButton; + MapModeButton: TToolButton; + ToolButton8: TToolButton; + ToolButton5: TToolButton; + AnimateButton: TToolButton; + ToolButton6: TToolButton; + ToolButton9: TToolButton; + ToolButton10: TToolButton; + SeqTab: TTabControl; + N24: TMenuItem; + ConverttoTileSequence1: TMenuItem; + InsertTileSequence1: TMenuItem; + RemoveTileSequence1: TMenuItem; + SeqBitmap: TImage; + SeqTimer: TTimer; + Code1: TMenuItem; + Generate1: TMenuItem; + CodeGenerationSettings1: TMenuItem; + PreviousPattern1: TMenuItem; + NextPattern1: TMenuItem; + ColorPatterns1: TMenuItem; + AddColorPattern1: TMenuItem; + RemoveColorPattern1: TMenuItem; + N17: TMenuItem; + SelectOutputDirectory1: TMenuItem; + ReplaceColors1: TMenuItem; + ReplaceColorsButton: TToolButton; + MapScrollFunction1: TMenuItem; + N25: TMenuItem; + SaveCurrentTile1: TMenuItem; + ImportEdlev: TToolButton; + ToolButton12: TToolButton; + Sequence1: TMenuItem; + N19: TMenuItem; + InsertHorizontal1: TMenuItem; + DeleteHorizontal1: TMenuItem; + InsertVertical1: TMenuItem; + DeleteVertical1: TMenuItem; + Tutorial1: TMenuItem; + N26: TMenuItem; + N27: TMenuItem; + OutputtoProjectDirectory1: TMenuItem; + N28: TMenuItem; + RecentProjects1: TMenuItem; + SmoothPalette1: TMenuItem; + N29: TMenuItem; + PaletteManager1: TMenuItem; + N30: TMenuItem; + ImportPovRayanimation1: TMenuItem; + MovePixels1: TMenuItem; + Right3: TMenuItem; + Left3: TMenuItem; + Down2: TMenuItem; + Up2: TMenuItem; + NoDelay1: TMenuItem; + ShowCurrentPalette1: TMenuItem; + N31: TMenuItem; + ImportMap1: TMenuItem; + ImportMapDialog: TOpenDialog; + ExportMapDialog: TSaveDialog; + ExportMap1: TMenuItem; + RefreshImportedTiles1: TMenuItem; + SelectionButton: TSpeedButton; + TileSelection: TShape; + GradientFill1: TMenuItem; + Horizontal3: TMenuItem; + Vertical3: TMenuItem; + Diagonal1: TMenuItem; + N32: TMenuItem; + ProjectInformation1: TMenuItem; + Fill1: TMenuItem; + Lighten1: TMenuItem; + Darken1: TMenuItem; + N33: TMenuItem; + N7: TMenuItem; + RealTimeLightening1: TMenuItem; + RTTimer: TTimer; + N34: TMenuItem; + Darker1: TMenuItem; + Lighter1: TMenuItem; + ChangeOffset1: TMenuItem; + Up3: TMenuItem; + Down3: TMenuItem; + Left4: TMenuItem; + Right4: TMenuItem; + ResetOffset1: TMenuItem; + HideTileSetPanel1: TMenuItem; + N35: TMenuItem; + UseOldNoiseFunctions1: TMenuItem; + ExportMapasImage1: TMenuItem; + RotateRight1: TMenuItem; + RotateLeft1: TMenuItem; + AntiAliasing1: TMenuItem; + aaOff: TMenuItem; + aa2: TMenuItem; + aa3: TMenuItem; + aa4: TMenuItem; + ReplaceColors2: TMenuItem; + Grid: TImage; + ShowTileGrid1: TMenuItem; + ReplaceSelectedTile1: TMenuItem; + N36: TMenuItem; + MoveMapLeft1: TMenuItem; + MoveMapRight1: TMenuItem; + NextMap1: TMenuItem; + PreviousMap1: TMenuItem; + N37: TMenuItem; + MapExportScaleDownFactor1: TMenuItem; + N210: TMenuItem; + N41: TMenuItem; + N82: TMenuItem; + N110: TMenuItem; + SplitColorPattern1: TMenuItem; + ShowMapLayer1: TMenuItem; + ShowBackLayer: TMenuItem; + ShowMidLayer: TMenuItem; + ShowFrontLayer: TMenuItem; + SetGridGuidelines1: TMenuItem; + ScaledPaste1: TMenuItem; + HalfSize1: TMenuItem; + N256ColorPalette1: TMenuItem; + N38: TMenuItem; + ReplaceCurrentTileSequence1: TMenuItem; + HistoryPanel: TPanel; + HistoryControlPanel: TPanel; + HistoryListBox: TListBox; + bHistoryRec: TSpeedButton; + bHistoryShow: TSpeedButton; + bHistoryClear: TSpeedButton; + ProjectLists1: TMenuItem; + UtilsTab: TPageControl; + RGBTab: TTabSheet; + PosTab: TTabSheet; + RGBPanel: TPanel; + RGBControlPanel: TPanel; + bRGBConvertAll: TSpeedButton; + bRGBEdit: TSpeedButton; + bRGBRun: TSpeedButton; + RGBConvListBox: TListBox; + Clip1: TMenuItem; + SelectNextClip1: TMenuItem; + SelectPreviousClip1: TMenuItem; + ReplaceColorUnderCursor1: TMenuItem; + OpacityTrackBar: TTrackBar; + N39: TMenuItem; + UseAsAlphaChannel1: TMenuItem; + AlphaPanel: TPanel; + AlphaPaintBox: TPaintBox; + ColorPatternsPanel: TPanel; + ColorPatternsImage: TImage; + N40: TMenuItem; + ShowUsedColorPatterns1: TMenuItem; + DoubleSize1: TMenuItem; + HideOnionSkin1: TMenuItem; + procedure Exit1Click(Sender: TObject); + procedure PalettePaint(Sender: TObject); + procedure FormResize(Sender: TObject); + procedure PaletteMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure PaletteMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure PaletteMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure FormCreate(Sender: TObject); + procedure BackGroundMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure RearrangePalette1Click(Sender: TObject); + procedure FromToPaint(Sender: TObject); + procedure FromToMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure FromToMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure FromToMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure ColorMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure ZoomIn1Click(Sender: TObject); + procedure ZoomOut1Click(Sender: TObject); + procedure TileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure TileMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure TileMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure SetDrawingTool(Sender: TObject); + procedure Up1Click(Sender: TObject); + procedure Down1Click(Sender: TObject); + procedure Left1Click(Sender: TObject); + procedure Right1Click(Sender: TObject); + procedure Horizontal1Click(Sender: TObject); + procedure Vertical1Click(Sender: TObject); + procedure Clear1Click(Sender: TObject); + procedure LineToolMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure Pattern1Click(Sender: TObject); + procedure ImportTiles1Click(Sender: TObject); + procedure NewTile1Click(Sender: TObject); + procedure TileBitmapMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure MatchColors1Click(Sender: TObject); + procedure Undo1Click(Sender: TObject); + procedure Redo1Click(Sender: TObject); + procedure Copy1Click(Sender: TObject); + procedure Paste1Click(Sender: TObject); + procedure Delete1Click(Sender: TObject); + procedure Cut1Click(Sender: TObject); + procedure MoveTileLeftClick(Sender: TObject); + procedure MoveTileRightClick(Sender: TObject); + procedure RemoveDuplicateTiles1Click(Sender: TObject); + procedure ColorMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure BackGroundMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure About1Click(Sender: TObject); + procedure Homepage1Click(Sender: TObject); + procedure ExportTiles1Click(Sender: TObject); + procedure BoundBoxPaint(Sender: TObject); + procedure Top1Click(Sender: TObject); + procedure Bottom1Click(Sender: TObject); + procedure Left2Click(Sender: TObject); + procedure Right2Click(Sender: TObject); + procedure DiagonalUp1Click(Sender: TObject); + procedure DiagonalDown1Click(Sender: TObject); + procedure ClearAll1Click(Sender: TObject); + procedure BoundBoxMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure NewTileCollection1Click(Sender: TObject); + procedure CreateNewTileCollection (Name: string; BW, BH: Integer; AddNew: Boolean); + procedure Properties1Click(Sender: TObject); + procedure TabChange(Sender: TObject); + procedure Toolbar1Click(Sender: TObject); + procedure ActualSize1Click(Sender: TObject); + procedure FitinWindow1Click(Sender: TObject); + procedure SetPaletteDepth(Sender: TObject); + procedure DuplicateTile1Click(Sender: TObject); + procedure SetBrightness(Sender: TObject); + procedure PaletteDblClick(Sender: TObject); + procedure SetEditorMode(NewMode: TEditorMode); + procedure BackgroundColor1Click(Sender: TObject); + procedure CopyTiles1Click(Sender: TObject); + procedure InsertNewTile1Click(Sender: TObject); + procedure PreviousTile1Click(Sender: TObject); + procedure NextTile1Click(Sender: TObject); + procedure FirstTile1Click(Sender: TObject); + procedure LastTile1Click(Sender: TObject); + procedure StretchPaste1Click(Sender: TObject); + procedure ToggleMultiple1Click(Sender: TObject); + procedure SelectBackMidFront(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure MirTileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure fUpsClick(Sender: TObject); + procedure Horizontal2Click(Sender: TObject); + procedure Vertical2Click(Sender: TObject); + procedure SelectCurrentTile1Click(Sender: TObject); + procedure Next1Click(Sender: TObject); + procedure Previous1Click(Sender: TObject); + procedure ToggleTileMapEditor1Click(Sender: TObject); + procedure DrawBounds (c: TCanvas; X, Y, Wid, Ht, lw, Bounds, Color: Integer); + procedure MapCodeButtonClick(Sender: TObject); + procedure Map1Click(Sender: TObject); + procedure ShowUsedColors1Click(Sender: TObject); + procedure UsedColorsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + procedure UsedColorsImageMouseMove(Sender: TObject; Shift: TShiftState; + X, Y: Integer); + procedure UsedColorsImageMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure MapProperties1Click(Sender: TObject); + procedure MapTabChange(Sender: TObject); + procedure ShowGrid1Click(Sender: TObject); + procedure bmpMapMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure bmpMapMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure bmpMapMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure SetMapDrawingTool(Sender: TObject); + procedure bmpPreviewMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure ShowMapCodes1Click(Sender: TObject); + procedure ShowBounds1Click(Sender: TObject); + procedure ClearArea1Click(Sender: TObject); + procedure ClipTabChange(Sender: TObject); + procedure RandomFill1Click(Sender: TObject); + procedure RemoveMap1Click(Sender: TObject); + procedure RemoveTileSet1Click(Sender: TObject); + procedure Save1Click(Sender: TObject); + procedure SaveAs1Click(Sender: TObject); + procedure Open1Click(Sender: TObject); + procedure NewGame1Click(Sender: TObject); + procedure Animate1Click(Sender: TObject); + procedure FirstFrame1Click(Sender: TObject); + procedure LastFrame1Click(Sender: TObject); + procedure NextFrame1Click(Sender: TObject); + procedure PreviousFrame1Click(Sender: TObject); + procedure AnimationTimerTimer(Sender: TObject); + procedure Default1Click(Sender: TObject); + procedure Faster1Click(Sender: TObject); + procedure Slower1Click(Sender: TObject); + procedure TileModeButtonClick(Sender: TObject); + procedure MapModeButtonClick(Sender: TObject); + procedure ConverttoTileSequence1Click(Sender: TObject); + procedure SeqTabChange(Sender: TObject); + procedure SeqTimerTimer(Sender: TObject); + procedure RemoveTileSequence1Click(Sender: TObject); + procedure InsertTileSequence1Click(Sender: TObject); + procedure Generate1Click(Sender: TObject); + procedure CodeGenerationSettings1Click(Sender: TObject); + procedure PreviousPattern1Click(Sender: TObject); + procedure NextPattern1Click(Sender: TObject); + procedure AddColorPattern1Click(Sender: TObject); + procedure RemoveColorPattern1Click(Sender: TObject); + procedure SelectOutputDirectory1Click(Sender: TObject); + procedure ReplaceColors1Click(Sender: TObject); + procedure MapScrollFunction1Click(Sender: TObject); + procedure SaveCurrentTile1Click(Sender: TObject); + procedure ImportEdlevClick(Sender: TObject); + procedure InsertHorizontal1Click(Sender: TObject); + procedure DeleteHorizontal1Click(Sender: TObject); + procedure InsertVertical1Click(Sender: TObject); + procedure DeleteVertical1Click(Sender: TObject); + procedure FormShow(Sender: TObject); + procedure Tutorial1Click(Sender: TObject); + procedure OutputtoProjectDirectory1Click(Sender: TObject); + procedure SmoothPalette1Click(Sender: TObject); + procedure PaletteManager1Click(Sender: TObject); + procedure ImportPovRayanimation1Click(Sender: TObject); + procedure Up2Click(Sender: TObject); + procedure Down2Click(Sender: TObject); + procedure Left3Click(Sender: TObject); + procedure Right3Click(Sender: TObject); + procedure NoDelay1Click(Sender: TObject); + procedure ShowCurrentPalette1Click(Sender: TObject); + procedure ImportMap1Click(Sender: TObject); + procedure ExportMap1Click(Sender: TObject); + procedure RefreshImportedTiles1Click(Sender: TObject); + procedure TileSelectionMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure TileSelectionMouseMove(Sender: TObject; Shift: TShiftState; + X, Y: Integer); + procedure TileSelectionMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure Horizontal3Click(Sender: TObject); + procedure Vertical3Click(Sender: TObject); + procedure Diagonal1Click(Sender: TObject); + procedure ProjectInformation1Click(Sender: TObject); + procedure Fill1Click(Sender: TObject); + procedure Lighten1Click(Sender: TObject); + procedure FormClose(Sender: TObject; var Action: TCloseAction); + procedure RealTimeLightening1Click(Sender: TObject); + procedure RTTimerTimer(Sender: TObject); + procedure Darker1Click(Sender: TObject); + procedure Lighter1Click(Sender: TObject); + procedure Up3Click(Sender: TObject); + procedure Down3Click(Sender: TObject); + procedure Left4Click(Sender: TObject); + procedure Right4Click(Sender: TObject); + procedure ResetOffset1Click(Sender: TObject); + procedure MapDisplayPaint(Sender: TObject); + procedure HideTileSetPanel1Click(Sender: TObject); + procedure UseOldNoiseFunctions1Click(Sender: TObject); + procedure FormKeyPress(Sender: TObject; var Key: Char); + procedure ExportMapasImage1Click(Sender: TObject); + procedure RotateRight1Click(Sender: TObject); + procedure RotateLeft1Click(Sender: TObject); + procedure aaClick(Sender: TObject); + procedure ReplaceColors2Click(Sender: TObject); + procedure ShowTileGrid1Click(Sender: TObject); + procedure ReplaceSelectedTile1Click(Sender: TObject); + procedure MoveMapLeft1Click(Sender: TObject); + procedure MoveMapRight1Click(Sender: TObject); + procedure NextMap1Click(Sender: TObject); + procedure PreviousMap1Click(Sender: TObject); + procedure N110Click(Sender: TObject); + procedure SplitColorPattern1Click(Sender: TObject); + procedure ShowBackLayerClick(Sender: TObject); + procedure ShowMidLayerClick(Sender: TObject); + procedure ShowFrontLayerClick(Sender: TObject); + procedure SetGridGuidelines1Click(Sender: TObject); + procedure HalfSize1Click(Sender: TObject); + procedure N256ColorPalette1Click(Sender: TObject); + procedure ReplaceCurrentTileSequence1Click(Sender: TObject); + procedure bHistoryClearClick(Sender: TObject); + procedure bHistoryShowClick(Sender: TObject); + procedure HistoryListBoxClick(Sender: TObject); + procedure ProjectLists1Click(Sender: TObject); + procedure bRGBEditClick(Sender: TObject); + procedure bRGBRunClick(Sender: TObject); + procedure SelectNextClip1Click(Sender: TObject); + procedure SelectPreviousClip1Click(Sender: TObject); + procedure ReplaceColorUnderCursor1Click(Sender: TObject); + procedure Edit1Click(Sender: TObject); + procedure UseAsAlphaChannel1Click(Sender: TObject); + procedure AlphaPaintBoxPaint(Sender: TObject); + procedure ShowUsedColorPatterns1Click(Sender: TObject); + procedure ColorPatternsImageMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + procedure ColorPatternsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + procedure ColorPatternsImageMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + procedure DoubleSize1Click(Sender: TObject); + procedure Edit1DrawItem(Sender: TObject; ACanvas: TCanvas; + ARect: TRect; Selected: Boolean); + procedure HideOnionSkin1Click(Sender: TObject); + private + { Private declarations } + public + { Public declarations } + Modified: Boolean; + Mode: TEditorMode; + W, H: Integer; + Scale: Integer; + Bounds: Integer; + bmpMap, + Bmp, + TempBmp, + VisualBmp, + ClipBmp: TBitmap; + bmpMapImage: TBitmap; // 2.5 - export map + OnionSkinBmp: TBitmap; // 2.5 - onion skin + AlphaBmp: TBitmap; // 2.5 - use tile as alpha channel + LastTileEdited: Integer; + OnionSkinTile: Integer; + TileTab: array of TileTabRec; + // tbr: TileBitmapRec; + // IgnorePaletteMouseDown: Boolean; + ColorSelect, + RightMouseButton, + FromToSelect, + FromToBackgroundSelect: Boolean; + PaletteOrder: Integer; { 0..MAX_PALETTE_ORDER - 1 } + LastFromToFirst, + LastFromToLast, + FromToFirst, + FromToLast: Integer; + FromToList: TFromToList; + ExFromToList: TExFromToList; + FromToCount: Integer; + LineSize: array[TDrawingTool] of Integer; + Erasing, + ShiftErasing: Boolean; // 2.0 + Drawing: Boolean; + ReadingColor: Boolean; + ShowOrigin: Boolean; + OrigColor: Integer; + Origin, CurPos: TPoint; + LastX, LastY: Integer; + LastShift: TShiftState; + LastButton: TMouseButton; + Busy: Boolean; + DrawingTool: TDrawingTool; + DrawColor, + FillColor: Integer; + DrawingShape: Boolean; + LineList: string; + Undo: array[0..MAX_UNDO - 1] of UndoRec; + UndoCount, + UndoPos: Integer; + Action: string; + SpecialColor: Integer; + UsedColorSelect: Boolean; + UsedPatternSelect: Boolean; + MaxRGB, + MaxR, + MaxG, + MaxB: Integer; + PaletteValues: array of Integer; + PalW, PalH, PalNH, PalNV: Integer; + CursorSize: Integer; + RightPanelWidth: Integer; + BMFCenterAdd: Integer; + lmp, + Clip, + Seq: LayerMapPtr; + CurMapW, CurMapH: Integer; + ClipW, ClipH: Integer; + SeqW, SeqH, + SeqFrame: Integer; + // bmp1, bmp2: TImage; + Zoom: Integer; + Area, LastArea: TRect; + DrawingInMap, + ReadingFromMap: Boolean; + MapDrawingTool: TMapDrawingTool; + MapOrigin: TPoint; + MapPos: TPoint; + Selection: Boolean; + ShiftState: TShiftState; + SkipDraw: Boolean; + FromToSave: array of FTSaveRec; + FromToSavePos: Integer; + OtherFromTo: FTSaveRec; // 2.54 + StartTime: TDateTime; + Sessions: Integer; + History: string; + CDROM: Boolean; + ReadParamFile: Boolean; //CMDLINE-OPS + resultCMD: Integer; //CMDLINE-OPS + ReadParamCMD: string; + RecentFiles: TStringList; + WinLeft, WinTop, WinWidth, WinHeight: Integer; // 2.55 + TileSelX1, TileSelY1, // 2.0 + TileSelX2, TileSelY2: Integer; + TileAreaX, TileAreaY, TileAreaW, TileAreaH: Integer; + TileSelOrgX, TileSelOrgY: Integer; + MovingTileSel, MovingTileSelPixels: Boolean; + GradientH, GradientV, GradientD: Boolean; // 2.0 + VisibleMapRegion: TRect; // 2.42 + + XShade: Integer; // 2.44 + YShade: Integer; + + aaN: Integer; // 2.5 + + MapGridX, MapGridY: Integer; // 2.54 + Quitting: Boolean; // 2.54 + + Pal256: Boolean; // 3.0 + Index256: Integer; + Row256: Integer; + LastIndex256: Integer; + Enable256, + LastEnable256: array[0..255] of Boolean; + + RGBConvScripts: array of TStringList; + + ColorUnderMousePointer: Integer; + + + procedure UpdateRecentFilesMenu; + function ColorMatch (C: Integer): Integer; + procedure InitUndo; + procedure ClearUndo; + procedure SaveUndo (Action: string); + procedure UpdateTileBitmap; + procedure UpdateBmp (UpdateAll: Boolean); + procedure SetTileSize (Width, Height: Integer); + procedure SetFromTo (N: Integer); + procedure DrawUsedFromToList; + procedure SetColor (NewColor: Integer; SetFT: Boolean; AddFT: Boolean); + procedure SetBackgroundColor (NewColor: Integer; Select: Boolean); + procedure DrawShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + procedure DrawFTShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + procedure DrawFTCircle (C: TCanvas; xp, yp: Integer; Shift: Boolean); + procedure DrawCursor; + procedure ShowStatusInfo; + procedure StartEdit (UpdateAll: Boolean); + procedure SwapWithUndo; + procedure SaveTempBmp; + procedure ShowRGB (color: Integer); + procedure HFlipBounds (var Bounds: Integer); + procedure VFlipBounds (var Bounds: Integer); + procedure RotateBounds (var Bounds: Integer; deg: Integer); + function NewTCName: string; + function NewMapName: string; + function TCNameOK (s: string; MayExist: Boolean): Boolean; + procedure IdError (id: string); + function HasCurrentBounds (Tile: SmallInt): Boolean; + procedure GetMCRTile (var MCR: MapCellRec; var Tile: Integer; + var Mir: Boolean; var Ups: Boolean); + procedure SetMCRTile (var MCR: MapCellRec; Tile: Integer; + Mir, Ups: Boolean); + procedure AddMCR (var MCR: MapCellRec; n: Integer); + procedure MirSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + procedure UpsSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + procedure DrawTile (TabIndex, N: Integer; var bmp: TImage; + var Mir: Boolean; var Ups: Boolean; var Rot: Boolean; + var FullBmp: TImage); + procedure DrawCurrentTile; + procedure ShowSelectedTile; + procedure SelectCurrentTile (n: Integer); + procedure HideUsedColors; + procedure DrawMap (Area: TRect; ExportingImage: Boolean; Clp, Sq: Boolean); + procedure ZoomMap; + function CombineMCR (OldMCR, NewMCR: MapCellRec): MapCellRec; + procedure CloseAll; + function SaveChanges: Boolean; + procedure ToggleAnimation; + function FindCurrentColorPattern (FindColor: Integer; All: Boolean): Integer; + procedure FindPatternForColor; + procedure SelectSavedFromToList; +{$IFDEF IMPORTEDLEV} + procedure ImportLevelTiles (dir, name: string; ww, hh: Integer; extc: Char = #0); + procedure ImportAnySize (dir: string; extc: Char); + procedure ImportLevelMap (dir, filename, name: string); +{$ENDIF} + procedure RecentFileClick (Sender: TObject); + procedure AddFileToRecentProjects (Filename: string); + procedure ReadConfigFile; + procedure WriteConfigFile; + procedure ShowTileSelection (Clip: Boolean); + procedure GetTileArea; + procedure SwapInt (var x, y: Integer); + function ColorPerc (RGB1, RGB2, Perc2, MaxPerc: Integer): Integer; + function ColorPercFT (i1, i2, Perc2, MaxPerc: Integer): Integer; + procedure UpdateMap; + procedure UpdateMapRegion(Region: TRect); + procedure UpdateTileGrid; + function CountEnabledColors: Integer; + procedure SaveHistoryCoords (x1, y1, x2, y2: Integer); + procedure LoadRGBConvNames; + function ConvertPixel (color: Integer): Integer; + end; + +var + MainForm: TMainForm; + +implementation + +uses Import, Clipbrd, About, Create, TileCopy, MCEdit, Hex, CGSettings, + SelectDir, Export, Scroll, Calc, PalMan, ImpPovAni, ReplaceColors, + InfoForm, Settings, ListsForm, RGBConvForm; + +{$R *.DFM} + + + +procedure ShowMessage (const sMsg: string); +begin + MessageDlg (sMsg, mtInformation, [mbOK], 0); +end; + + +var + DtTm: TDateTime; + aiDtTm: array[0..1] of Integer absolute DtTm; + +function UpCaseStr (s: string): string; + var + i: Integer; +begin + for i := 1 to Length (s) do + s[i] := UpCase (s[i]); + UpCaseStr := s; +end; + +function FileExists (Filename: string): Boolean; + var + SR: TSearchRec; +begin + Result := FindFirst (Filename, faArchive, SR) = 0; + FindClose (SR); +end; + +function DirExists (Filename: string): Boolean; + var + SR: TSearchRec; +begin + Result := FindFirst (Filename, faDirectory, SR) = 0; + FindClose (SR); +end; + +procedure Msg (s: string); +begin + MessageDlg (s, mtInformation, [mbOk], 0); +end; + + +function FilePath (Name: string): string; +begin + if Pos ('\', Name) = 0 then + FilePath := '' + else + begin + while (Length (Name) > 0) and (Name[Length (Name)] <> '\') do + Delete (Name, Length (Name), 1); + FilePath := Name; + end; +end; + +function WithoutPath (Name: string): string; + var + i: Integer; +begin + i := Length (Name); + while (i > 0) and (Name[i] <> '\') do + Dec (i); + Delete (Name, 1, i); + WithoutPath := Name; +end; + +function WithoutExt (Name: string; Ext: string): string; + var + { i: Integer; } + sPath, sFile: string; +begin +{ + i := Pos (Ext, Name); + if i <> Length (Name) - Length (Ext) + 1 then + WithoutExt := Name + else + WithoutExt := Copy (Name, 1, Length (Name) - Length (Ext)); +} + // 2.34 + sPath := FilePath (Name); + sFile := WithoutPath (Name); + while Pos ('.', sFile) > 0 do + Delete (sFile, Length (sFile), 1); + WithoutExt := sPath + sFile; +end; + +function CreatePath (Name: string): string; + var + i: Integer; + p, s: string; +begin + s := Name; + while Pos ('\', s) > 0 do + begin + i := Pos ('\', s); + p := Copy (Name, 1, i - 1); + if not ((Length (p) = 2) and (p[2] = ':')) then + if not DirExists (p) then + mkdir (p); + s[i] := #0; + end; +end; + +function ProjectName: string; + var + Name: string; +begin + Name := Filename; + if Name = '' then + Name := DEFAULT_NAME + DEFAULT_EXT; + ProjectName := WithoutPath (WithoutExt (Name, DEFAULT_EXT)); +end; + +function ValidNumber (var s: string): Boolean; + var + N: Integer; + Code: Integer; +begin + if (Length (s) > 1) then + if Copy (UpCaseStr (s), 1, 2) = '0X' then + begin + Delete (s, 1, 2); + Insert ('$', s, 1); + Val (s, N, Code); + Str (N, s); + end; + Val (s, N, Code); + ValidNumber := Code = (N - N); +end; + +procedure ResizeBitmap (var img: TImage); +begin + img.Picture.Bitmap.PixelFormat := pf24bit; + img.Picture.Bitmap.Width := img.Width; + img.Picture.Bitmap.Height := img.Height; +end; + +procedure FillBitmap (var img: TImage; rgb: Integer); + var + i: Integer; +begin + img.Picture.Bitmap.PixelFormat := pf24bit; + with img.Picture.Bitmap.Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := rgb; + i := pen.Width; + FillRect (Rect (-i, -i, + img.Picture.Bitmap.Width + i, + img.Picture.Bitmap.Height + i)); + end; +end; + +procedure TMainForm.InitUndo; + var + i: Integer; +begin + for i := 0 to MAX_UNDO - 1 do + begin + Undo[i].Bmp := TBitmap.Create; + Undo[i].Bmp.PixelFormat := pf24bit; + end; +end; + +procedure TMainForm.ClearUndo; +begin + UndoCount := 0; + UndoPos := -1; + Redo1.Enabled := FALSE; +{ + RedoButton.Down := FALSE; + RedoButton.Enabled := FALSE; +} + Undo1.Enabled := FALSE; +{ + UndoButton.Down := FALSE; + UndoButton.Enabled := FALSE; +} +end; + +procedure TMainForm.SaveUndo (Action: string); + var + i: Integer; + ur: UndoRec; +begin + if UndoPos + 1 <> UndoCount then + begin + UndoCount := UndoPos + 1; + Redo1.Caption := '&Redo'; + Redo1.Enabled := FALSE; + { + RedoButton.Down := FALSE; + RedoButton.Enabled := FALSE; + } + end; + if UndoCount >= MAX_UNDO - 1 then + begin + ur := Undo[0]; + for i := 0 to UndoCount - 1 do + Undo[i] := Undo[i + 1]; + Undo[UndoCount] := ur; // don't lose initialized TBitmaps! + end + else + begin + Inc (UndoCount); + Inc (UndoPos); + end; + Undo[UndoPos].Bmp.Width := W; + Undo[UndoPos].Bmp.Height := H; + Undo[UndoPos].Bmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + Undo[UndoPos].ActionName := Action; + Undo[UndoPos].HistoryCoords := ''; + + Undo1.Caption := '&Undo ' + Action; + Undo1.Enabled := TRUE; +{ + UndoButton.Enabled := TRUE; +} +end; + +procedure TMainForm.Exit1Click(Sender: TObject); +begin +// if Modified then +// if not SaveChanges then +// Exit; + Close; +end; + + +function LimitRGB (X: Integer): Integer; +begin + if X < 0 then + LimitRGB := 0 + else + if X > 255 then + LimitRGB := 255 + else + LimitRGB := X; +end; + +function MakePalRGB (r, g, b, l: Integer): Integer; + var + Light: Integer; +begin + Light := l; + MakePalRGB := RGB (LimitRGB (r + Light), + LimitRGB (g + Light), + LimitRGB (b + Light)); +end; + + + +procedure TMainForm.PalettePaint(Sender: TObject); + var + Max: Integer; + iW, iH, x1, y1, x2, y2, k: Integer; + R, G, B, RR, GG, BB: Integer; + Wd, Ht: Integer; + i, j, l, m, n, p: Integer; + OldShowCurPal: Boolean; + Bmp: TBitmap; + + function GetColorCircle (i, j: Integer): Integer; + var + k, l, m, n: Integer; + begin + k := (j * 6) mod Ht; + l := (j * 6) div Ht; + m := 256 * k div Ht; + n := 256 - m; + case l of + 0: begin + RR := 255; + GG := 0; + BB := n; + // BB := Round (256 * Cos (k / Ht)); + end; + 1: begin + RR := 255; + GG := m; + BB := 0; + end; + 2: begin + RR := n; + GG := 255; + BB := 0; + end; + 3: begin + RR := 0; + GG := 255; + BB := m; + + end; + 4: begin + RR := 0; + GG := n; + BB := 255; + end; + else + begin + RR := m; + GG := 0; + BB := 255; + end; + end; + + Result := MakePalRGB (i * RR div Wd, + i * GG div Wd, + i * BB div Wd, + i * 255 div Wd); + end; + +begin + Max := MaxR * MaxG * MaxB; + iW := 2 * MaxB; + iH := Max div iW; + + if Pal256 then + begin + iW := 8; + iH := 32; + end; + + j := (RightPanel.Height div 2) div iH * iH + 10; + if j <> PalettePanel.Height then + PalettePanel.Height := j; + + Wd := Palette.Width; + Ht := Palette.Height; + if Ht > 2 * Wd then + begin + iW := 1 * MaxB; + iH := Max div iW; + end; + if Wd > Ht then + begin + iW := 3 * MaxB; + iH := Max div iW; + end; + + if Pal256 then + begin + Max := 256; + iW := 8; + iH := 32; + end; + + SetLength (PaletteValues, Max); + PalNH := iW; + PalNV := iH; + PalW := Wd; + PalH := Ht; + + with Palette.Canvas do + begin + if Pal256 then + begin // 256-color palette + with TileTab[Tab.TabIndex].tbr do + begin + p := PaletteNumber; + OldShowCurPal := ShowCurrentPalette1.Checked; + ShowCurrentPalette1.Checked := FALSE; + + + for k := 0 to 255 do + begin + + Brush.Color := 0; + if (p >= 0) then + begin + if (k < aiPalSize[p]) then + Brush.Color := aaiPal[p, k]; + end + else + Brush.Color := GetColorCircle (Wd * (k mod 8) div 8, Ht * (k div 8) div 32); + + Brush.Style := bsSolid; + Pen.Style := psClear; + x1 := (k mod iW) * Wd div iW; + y1 := (k div iW) * Ht div iH; + x2 := ((k mod iW) + 1) * Wd div iW; + y2 := ((k div iW) + 1) * Ht div iH; + Rectangle (x1, y1, x2 + 1, y2 + 1); + PaletteValues[k] := Brush.Color; + + if not Enable256[k] then + begin + Brush.Style := bsBDiagonal; + Brush.Color := clBlack; + Rectangle (x1, y1, x2 + 1, y2 + 1); + Brush.Style := bsFDiagonal; + Brush.Color := clWhite; + Rectangle (x1, y1, x2 + 1, y2 + 1); + end; + end; + + + ShowCurrentPalette1.Checked := OldShowCurPal; + end; + end + else + begin + if not SmoothPalette1.Checked then // generated 6x6x6/7x7x7/8x8x8 palettes + begin + OldShowCurPal := ShowCurrentPalette1.Checked; + ShowCurrentPalette1.Checked := FALSE; + k := 0; + for R := 0 to MaxR - 1 do + for G := 0 to MaxG - 1 do + for B := 0 to MaxB - 1 do + begin + case PaletteOrder of + 1: begin RR := G; GG := B; BB := R; end; + 2: begin RR := B; GG := R; BB := G; end; + 3: begin RR := R; GG := B; BB := G; end; + 4: begin RR := G; GG := R; BB := B; end; + 5: begin RR := B; GG := G; BB := R; end; + else begin RR := R; GG := G; BB := B; end; + end; + Brush.Color := + ColorMatch (RGB (RR * 255 div (MaxR - 1), + GG * 255 div (MaxG - 1), + BB * 255 div (MaxB - 1))); + Brush.Style := bsSolid; + Pen.Style := psClear; + x1 := (k mod iW) * Wd div iW; + y1 := (k div iW) * Ht div iH; + x2 := ((k mod iW) + 1) * Wd div iW; + y2 := ((k div iW) + 1) * Ht div iH; + Rectangle (x1, y1, x2 + 1, y2 + 1); + + PaletteValues[k] := Brush.Color; + + Inc (k); + end; + ShowCurrentPalette1.Checked := OldShowCurPal; + end + else + begin // smooth palette + + //for j := 0 to Ht - 1 do + // for i := 0 to Wd - 1 do + // Pixels[i, j] := GetColorCircle (i, j); // very slow for some reason + + Bmp := TBitmap.Create(); + Bmp.Width := Wd; + Bmp.Height := Ht; + + for j := 0 to Ht - 1 do + for i := 0 to Wd - 1 do + Bmp.Canvas.Pixels[i, j] := GetColorCircle (i, j); + + Draw(0, 0, Bmp); + + Bmp.FreeImage(); + + end; + end; + + end; + + RearrangePalette1.Enabled := not SmoothPalette1.Checked; +end; + +procedure TMainForm.FormResize(Sender: TObject); + var + Wd, Ht: Integer; + X, Y: Integer; + i: Integer; +begin + if Quitting then Exit; + + Wd := (W + 2 * BORDER_W) * Scale; + Ht := (H + 2 * BORDER_H) * Scale; + X := ScrollBox.ClientWidth div 2 - Wd div 2; + Y := ScrollBox.ClientHeight div 2 - Ht div 2; + if X < 0 then + X := 0; + if Y < 0 then + Y := 0; + with Tile do + begin + Left := X; + Top := Y; + Width := Wd; + Height := Ht; + end; + + Palette.Repaint; + i := RightPanel.Height - PalettePanel.Height - ColorsPanel.Height - ProgressPanel.Height; + PatternPanel.Height := PatternPanel.Width; + if PatternPanel.Height > i then + PatternPanel.Height := i; + UpdateBmp (TRUE); + + if Mode = mTile then + begin + StatusBar.Panels[4].Text := Format ('%dx', [Scale]); + ZoomOut1.Enabled := (Scale > 1); + ZoomIn1.Enabled := (Scale < MAX_SCALE); + end; + if Mode = mMap then + begin + ZoomIn1.Enabled := (Zoom > 1); + ZoomOut1.Enabled := (Zoom < MAX_ZOOM); + end; + + DrawCursor; +end; + +procedure TMainForm.PaletteMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + i, j, k: Integer; +begin +{ + if IgnorePaletteMouseDown then + begin + IgnorePaletteMouseDown := FALSE; + Exit; + end; +} + LastIndex256 := -1; + + i := X * PalNH div PalW; + j := Y * PalNV div PalH; + + if (i >= 0) and (i < PalNH) and (j >= 0) and (j < PalNV) then + begin + Row256 := 32 * j div PalNV; + Index256 := Row256 * 8 + (8 * i div PalNH); + + if SmoothPalette1.Checked then + k := Palette.Canvas.Pixels[X - 1, Y - 1] + else + k := PaletteValues[j * PalNH + i]; + end; + + if Button = mbLeft then + begin + if k = Color.Brush.Color then + Inc (FromToCount); + ColorSelect := TRUE; + end; + if Button = mbRight then + RightMouseButton := TRUE; + PaletteMouseMove (Sender, Shift, X, Y); +end; + +procedure GetRGB (RGB: Integer; var R: Integer; var G: Integer; var B: Integer); +begin + R := RGB; + G := RGB div $100; + B := RGB div $10000; + R := R and $FF; + G := G and $FF; + B := B and $FF; +end; + +function ColorBetween (RGB1, RGB2: Integer): Integer; + var + R1, G1, B1: Integer; + R2, G2, B2: Integer; + C: Integer; +begin + GetRGB (RGB1, R1, G1, B1); + GetRGB (RGB2, R2, G2, B2); + C := RGB ((R1 + R2) div 2, (G1 + G2) div 2, (B1 + B2) div 2); + if C = TRANS_COLOR then + if (RGB1 <> TRANS_COLOR) and (RGB2 <> TRANS_COLOR) then + Inc (C); + ColorBetween := C; +end; + +function Grey (RGB: Integer): Integer; + var + R, G, B: Integer; +begin + GetRGB (RGB, R, G, B); + Grey := (R + G + B) div 3; +end; + +function Blend (RGB1, RGB2: Integer; w1, w2: Integer): Integer; + var + R1, G1, B1: Integer; + R2, G2, B2: Integer; + C: Integer; +begin + GetRGB (RGB1, R1, G1, B1); + GetRGB (RGB2, R2, G2, B2); + C := RGB ((w1 * R1 + w2 * R2) div (w1 + w2), + (w1 * G1 + w2 * G2) div (w1 + w2), + (w1 * B1 + w2 * B2) div (w1 + w2)); + if C = TRANS_COLOR then + if (RGB1 <> TRANS_COLOR) and (RGB2 <> TRANS_COLOR) then + Inc (C); + Blend := C; +end; + +procedure TMainForm.PaletteMouseMove(Sender: TObject; Shift: TShiftState; + X, Y: Integer); + var + i, j, k, Index: Integer; + ft: Integer; + R, G, B: Integer; +begin + i := X * PalNH div PalW; + j := Y * PalNV div PalH; + if (i >= 0) and (i < PalNH) and (j >= 0) and (j < PalNV) then + begin + Index := j * PalNH + i; + if SmoothPalette1.Checked then + k := Palette.Canvas.Pixels[X - 1, Y - 1] + else + k := PaletteValues[j * PalNH + i]; + + if Pal256 then + begin + k := PaletteValues[Index]; + + if ColorSelect then + if not Enable256[Index] then + if CountEnabledColors < 256 then + begin + LastEnable256 := Enable256; + for i := 0 to 255 do + Enable256[i] := True; + Palette.Repaint; + end; + end; + + // 2.0 select from current color to new + + if ssShift in Shift then + begin + ShowRGB (k); + + if ColorSelect then + begin + + if (FromToFirst = FromToLast) then + begin + for ft := 0 to MAX_FROM_TO - 1 do + FromToList[ft] := ColorPerc (Color.Brush.Color, + k, ft, MAX_FROM_TO); + FromToFirst := 0; + FromToLast := MAX_FROM_TO - 1; + end + else + begin + for ft := FromToFirst + 1 to FromToLast do + FromToList[ft] := ColorPerc (FromToList[FromToFirst], + k, Abs (ft - FromToFirst), + Abs (FromToLast - FromToFirst)); + for ft := FromToFirst - 1 downto FromToLast do + FromToList[ft] := ColorPerc (FromToList[FromToFirst], + k, Abs (ft - FromToFirst), + Abs (FromToLast - FromToFirst)); + end; + + end; + + // 2.43 (bug fix) + for ft := 0 to MAX_FROM_TO - 1 do + begin + GetRGB (FromToList[ft], R, G, B); + ExFromToList[ft, 0] := R; + ExFromToList[ft, 1] := G; + ExFromToList[ft, 2] := B; + end; + FromToPaint (Sender); + + end + else + begin + ShowRGB (k); + if ColorSelect then + SetColor (k, TRUE, ssCtrl in Shift); + end; + + + if RightMouseButton then + if Pal256 then + begin + j := Byte (not Enable256[Index]); + if Index <> LastIndex256 then + begin + case (2 * byte (ssCtrl in Shift) + byte (ssShift in Shift)) of + 1: begin { shift } + for i := 0 to 7 do + Enable256[(Index and (not 7)) + i] := Boolean (j); + LastIndex256 := Index; + Palette.Repaint; + end; + 2: begin { ctrl } + Enable256[Index] := Boolean (j); + LastIndex256 := Index; + Palette.Repaint; + end; + 3: begin { shift + ctrl } + for i := 0 to 255 do + Enable256[i] := False; + for i := 0 to 7 do + Enable256[(Index and (not 7)) + i] := True; + LastIndex256 := Index; + Palette.Repaint; + ShowRGB (k); + ColorSelect := TRUE; + SetColor (k, TRUE, FALSE); + ColorSelect := FALSE; + end; + + else + if CountEnabledColors = 256 then + SetBackgroundColor (k, FALSE) + else + begin + for i := 0 to 255 do + Enable256[i] := Boolean (j); + LastIndex256 := Index; + Palette.Repaint; + end; + + end; + end; + + + end + else + SetBackgroundColor (k, FALSE); + + end; +end; + +procedure TMainForm.PaletteMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + ColorSelect := FALSE; + if Button = mbRight then + RightMouseButton := FALSE; +end; + + +procedure TMainForm.UpdateRecentFilesMenu; + var + mi: TMenuItem; + i, j: Integer; +begin + for i := RecentProjects1.Count - 1 downto 0 do + RecentProjects1.Delete (i); + j := RecentFiles.Count; + if j > 9 then + j := 9; + for i := 0 to j - 1 do + begin + mi := TMenuItem.Create (MainMenu); + mi.Caption := '&' + IntToStr (i + 1) + ' ' + RecentFiles.Strings[i]; + mi.Tag := i; + mi.OnClick := RecentFileClick; + RecentProjects1.Add (mi); + end; + RecentProjects1.Enabled := RecentFiles.Count > 0; +end; + + +procedure TMainForm.FormCreate(Sender: TObject); + var + s: string; + i: Integer; + F: TextFile; + tdt: TDrawingTool; +begin + StartTime := Now; + Sessions := 0; +{$IFDEF IMPORTEDLEV} + ImportEdlev.Visible := TRUE; +{$ENDIF} + + // 2.43 + for tdt := Low (LineSize) to High (LineSize) do + LineSize[tdt] := 1; + + CursorSize := DEFAULT_CURSOR_SIZE; + RightPanelWidth := RightPanel.Width; + LastFromToFirst := 0; + LastFromToLast := MAX_FROM_TO - 1; + Zoom := ZOOM_FACTOR; + + VisibleMapRegion := Rect(0, 0, 0, 0); + + ApplPath := ParamStr (0); + i := Length (ApplPath); + while (i > 0) and (ApplPath[i] <> '\') do + begin + Delete (ApplPath, Length (ApplPath), 1); + Dec (i); + end; + + + RecentFiles := TStringList.Create; + ReadConfigFile; + + + CDROM := FALSE; + try + AssignFile (F, ApplPath + '$TS$Tmp$.$$$'); + ReWrite (F); + CloseFile (F); + Erase (F); + except + CDROM := TRUE; + end; + if CDROM then + begin + ShowMessage ('Tile Studio is running from a read-only drive. '#13 + + 'Some options might not be available.'); + end; + + PatternPanel.Height := PatternPanel.Width; + Pattern.Height := Pattern.Width; + + Homepage1.Caption := APPL_NAME + ' &Homepage'; + OpenDialog.DefaultExt := DEFAULT_EXT; + SaveDialog.DefaultExt := DEFAULT_EXT; + s := APPL_NAME + ' Project (*' + DEFAULT_EXT + + ')|*' + DEFAULT_EXT + '|All files (*.*)|*.*'; + OpenDialog.Filter := s; + SaveDialog.Filter := s; + + MapDisplay.Canvas.Brush.Style := bsClear; + MapDisplay.ControlStyle := MapDisplay.ControlStyle + [csOpaque]; + bmpMap := TBitmap.Create; + bmpMap.PixelFormat := pfMap; + ClipBitmap.Picture.Bitmap.PixelFormat := pfMap; + SeqBitmap.Picture.Bitmap.PixelFormat := pfMap; + +{ bmp1 := TImage.Create (InvPanel); } + bmp1.Transparent := TRUE; + bmp1.Picture.Bitmap.TransparentColor := TRANS_COLOR; +{ bmp2:= TImage.Create (InvPanel); } + bmp2.Transparent := FALSE; + SelBmp.Transparent := TRUE; + SelBmp.Picture.Bitmap.TransparentColor := TRANS_COLOR; +{ + if not Ok then + begin + MessageDlg ('This program cannot run with 16 or 256 color display,' + + 'Please change your desktop settings to High Color or True Color.', + mtError, [mbOk], 0); + Close; + end; +} + + + // SetEditorMode (mTile); // [ 732697 ] Access violation when starting TS 2.41 on XP + + SpecialColor := SPECIAL_COLOR; + + MaxRGB := 8; + MaxR := 8; + MaxG := 8; + MaxB := 8; + + InitUndo; + ClearUndo; + + VisualBmp := TBitmap.Create; + VisualBmp.PixelFormat := pf24bit; + VisualBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(VisualBmp.Canvas.Handle, HALFTONE); + + TempBmp := TBitmap.Create; + TempBmp.PixelFormat := pf24bit; + TempBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(TempBmp.Canvas.Handle, HALFTONE); + + Bmp := TBitmap.Create; + Bmp.PixelFormat := pf24bit; + Bmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(Bmp.Canvas.Handle, HALFTONE); + + ClipBmp := TBitmap.Create; + ClipBmp.PixelFormat := pf24bit; + ClipBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(ClipBmp.Canvas.Handle, HALFTONE); + + OnionSkinBmp := TBitmap.Create; + OnionSkinBmp.PixelFormat := pf24bit; + OnionSkinBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(OnionSkinBmp.Canvas.Handle, HALFTONE); + OnionSkinTile := -1; + LastTileEdited := -1; + + AlphaBmp := TBitmap.Create; + AlphaBmp.PixelFormat := pf24bit; + AlphaBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(AlphaBmp.Canvas.Handle, HALFTONE); + + + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + + SetEditorMode (mTile); // 2.43 moved to here + + StartEdit (TRUE); + + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + + Scale := DEFAULT_SCALE; + ColorSelect := FALSE; + RightMouseButton := FALSE; + FromToCount := 0; + SetBackgroundColor (DEFAULT_BACKGR_COLOR, FALSE); + SetColor (ColorMatch (DEFAULT_COLOR), TRUE, FALSE); +// SetFromTo (FromToCount); + Erasing := FALSE; + ShiftErasing := FALSE; + + PaletteOrder := 1; + SelectBackMidFront (pMid, mbLeft, [], 1, 1); + + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; + + ReadParamFile := ParamCount > 0; + if ReadParamFile then + FileToOpen := ParamStr (1); + + TileSelX1 := 0; + TileSelY1 := 0; + TileSelX2 := -1; + TileSelY2 := -1; + MovingTileSel := FALSE; + MovingTileSelPixels := FALSE; + + Busy := FALSE; + + Modified := FALSE; + + // apply config data + UpdateRecentFilesMenu; + + MainForm.Position := poDesigned; + MainForm.Left := WinLeft; + MainForm.Top := WinTop; + MainForm.Width := WinWidth; + MainForm.Height := WinHeight; + + + XShade := 0; + YShade := 0; + + ShowTileGrid1.Checked := Grid.Visible; + + MapGridX := 0; + MapGridY := 0; + Quitting := False; + + Pal256 := FALSE; + + ClipTab.Align := alClient; + UtilsTab.Align := alClient; + + LoadRGBConvNames; + +end; { FormCreate } + +procedure TMainForm.BackGroundMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Button = mbRight then + SetBackgroundColor (DEFAULT_BACKGR_COLOR, TRUE) + else + SetBackgroundColor (Background.Brush.Color, TRUE); +end; + +procedure TMainForm.UpdateTileBitmap; +begin + with TileTab[Tab.TabIndex] do + begin + TileBitmap.Picture.Bitmap := tbr.TileBitmap; + TileBitmap.Width := tbr.TileCount * tbr.W; + TileBitmap.Height := tbr.H; + TileBitmap.Picture.Bitmap.Width := tbr.TileCount * tbr.W; + TileBitmap.Picture.Bitmap.Height := tbr.H; + + with TileBitmap.Picture.Bitmap.Canvas do + begin + Brush.Color := BackGround.Brush.Color; + FillRect (Rect (0, 0, TileBitmap.Width, TileBitmap.Height)); + Draw (0, 0, tbr.TileBitmap); + end; + + end; +end; + +procedure TMainForm.UpdateBmp (UpdateAll: Boolean); + var + x, y, i, j, k, ov: Integer; + TmpBmp: TBitmap; + + procedure ClearEdge; + var + ov: Integer; + begin + with VisualBmp.Canvas do + begin + Pen.Style := psClear; + Brush.Style := bsSolid; + Brush.Color := ColorBetween (Background.Brush.Color, clSilver); + FillRect (MakeRect (0, 0, W + 2 * BORDER_W, BORDER_H)); + FillRect (MakeRect (0, BORDER_H, BORDER_W, H)); + FillRect (MakeRect (W + BORDER_W, BORDER_H, BORDER_W, H)); + FillRect (MakeRect (0, H + BORDER_H, W + 2 * BORDER_W, BORDER_H)); + ov := TileTab[Tab.TabIndex].tbr.Overlap; + if ov > 0 then + begin + Brush.Color := ColorBetween (Brush.Color, clSilver); + FillRect (MakeRect (0, 0, W + 2 * BORDER_W, BORDER_H)); + FillRect (MakeRect (0, BORDER_H, BORDER_W, ov)); + FillRect (MakeRect (W + BORDER_W, BORDER_H, BORDER_W, ov)); + end; + end; + end; + + var + OfsX, OfsY: Integer; // 2.4 + tmpX1, tmpY1, tmpX2, tmpY2: Integer; // 3.0 + tmpS, sNum: string; + iCode: Integer; + oldRGB, newRGB: Integer; + opacity: Integer; + alpha: Integer; + w1, w2: Integer; + +begin { UpdateBMP } +// Caption := Format ('UndoPos: %d UndoCount: %d', [UndoPos, UndoCount]); + + ShowStatusInfo; + + if Quitting then Exit; + + if Mode = mTile then + begin + alpha := -1; + if UseAsAlphaChannel1.Checked then + if (AlphaBmp.Width = W) and (AlphaBmp.Height = H) then + begin + if LastTileEdited <> TileTab[Tab.TabIndex].tbr.Current then + LastTileEdited := TileTab[Tab.TabIndex].tbr.Current + else + alpha := 0; + end; + + // set opacity of last action + opacity := OpacityTrackBar.Position; + if UpdateAll then + if (opacity <> OpacityTrackBar.Max) or (alpha <> -1) then + if (UndoCount > 0) and (UndoPos >= 0) then + begin + for tmpY1 := 0 to H - 1 do + for tmpX1 := 0 to W - 1 do + begin + newRGB := Bmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H]; + oldRGB := Undo[UndoPos].Bmp.Canvas.Pixels[tmpX1, tmpY1]; + if (newRGB <> TRANS_COLOR) and (oldRGB <> TRANS_COLOR) then + begin + w1 := OpacityTrackBar.Max; + w2 := opacity; + + if alpha <> -1 then + begin + alpha := AlphaBmp.Canvas.Pixels[tmpX1, tmpY1]; + if (alpha = TRANS_COLOR) then + alpha := 0 + else + alpha := Grey (alpha); + w1 := 256 * OpacityTrackBar.Max; + w2 := 256 * alpha * opacity div 256; + end; + + //w1 := OpacityTrackBar.Max - opacity; + //w2 := opacity; + + + Bmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H] := Blend (oldRGB, newRGB, w1 - w2, w2); + + end; + end; + end; + + TmpBmp := TBitmap.Create; + SetStretchBltMode(TmpBmp.Canvas.Handle, HALFTONE); + with TmpBmp do + begin + PixelFormat := pf24bit; + Width := W; + Height := H; + Transparent := TRUE; + // TransparentMode := tmFixed; + TransparentColor := TRANS_COLOR; + + Canvas.CopyRect (Rect (0, 0, W, H), Bmp.Canvas, + MakeRect (BORDER_W, BORDER_H, W, H)); + end; + ClearEdge; + with VisualBmp.Canvas do + begin + Brush.Color := Background.Brush.Color; + FillRect (MakeRect (BORDER_W, BORDER_H, W, H)); + Draw (BORDER_W, BORDER_H, TmpBmp); + end; + + if OnionSkinTile <> -1 then + if not HideOnionSkin1.Checked then + begin + for tmpY1 := 0 to H - 1 do + for tmpX1 := 0 to W - 1 do + begin + newRGB := OnionSkinBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H]; + oldRGB := VisualBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H]; + if (newRGB <> TRANS_COLOR) and (oldRGB <> TRANS_COLOR) then + VisualBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H] := Blend (oldRGB, newRGB, 125, 50); + end; + end; + + if Drawing then + if DrawingShape then + begin + VisualBmp.Canvas.Pen := Bmp.Canvas.Pen; + VisualBmp.Canvas.Brush := Bmp.Canvas.Brush; + if Bmp.Canvas.Pen.Color = TRANS_COLOR then + begin + VisualBmp.Canvas.Pen.Color := Background.Brush.Color; + if VisualBmp.Canvas.Brush.Style <> bsClear then // 2.44: bug fix + VisualBmp.Canvas.Brush.Color := Background.Brush.Color; + end; + DrawFTShape (Origin.X, Origin.Y, CurPos.X, CurPos.Y, VisualBmp.Canvas); + DrawingShape := FALSE; + ClearEdge; + end; + + + if bHistoryShow.Down then + begin + for i := 0 to HistoryListBox.Items.Count - 1 do + if HistoryListBox.Selected[i] then + begin + tmpS := HistoryListBox.Items[i]; + if tmpS <> '' then + begin + tmpS := tmpS + ','; + for j := 1 to 4 do + begin + k := Pos (',', tmpS); + sNum := Copy (tmpS, 1, k - 1); + Delete (tmpS, 1, k); + case j of + 1: Val (sNum, tmpX1, iCode); + 2: Val (sNum, tmpY1, iCode); + 3: Val (sNum, tmpX2, iCode); + 4: Val (sNum, tmpY2, iCode); + end; + end; + VisualBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H] := $F808F8; + VisualBmp.Canvas.Pixels[tmpX2 + BORDER_W, tmpY2 + BORDER_H] := $F808F8; + + end; + end; + end; + + if UpdateAll then + with TileTab[Tab.TabIndex] do + begin + if (tbr.TileBitmap <> nil) and (tbr.Current < tbr.TileCount) then + begin + TileBitmap.Width := tbr.TileBitmap.Width; + TileBitmap.Height := tbr.TileBitmap.Height; + + // update the actual Tile Bitmap: + tbr.TileBitmap.Canvas.CopyRect (MakeRect (tbr.Current * W, 0, W, H), + TmpBmp.Canvas, Rect (0, 0, W, H)); + + + TileBitmap.Picture.Bitmap.Canvas.CopyRect + (MakeRect (tbr.Current * W, 0, W, H), + // TmpBmp.Canvas, Rect (0, 0, W, H)); + VisualBmp.Canvas, + MakeRect (BORDER_W, BORDER_H, W, H)); + end; +// TileBitmap.Picture.Bitmap := tbr.TileBitmap; + end; + + + with Pattern.Canvas do + begin + ov := TileTab[Tab.TabIndex].tbr.Overlap; + x := Pattern.Width div 2 - W div 2; + y := Pattern.Height div 2 - (H - ov) div 2; + + OfsX := 0; // 2.4 + OfsY := 0; + with TileTab[Tab.TabIndex].tbr do + begin + if Current < Length (OffsetX) then + OfsX := OffsetX[Current]; + if Current < Length (OffsetY) then + OfsY := OffsetY[Current]; + end; + + if UpdateAll or (OfsX <> 0) or (OfsY <> 0) then + begin + Brush.Color := Background.Brush.Color; + FillRect (MakeRect (0, 0, Width, Height)); + end; + + if (not Pattern1.Checked) or (not UpdateAll) then + begin + { if ov > 0 then } + Draw (x + OfsX, y + OfsY, TmpBmp); + TmpBmp.Canvas.CopyRect (Rect (0, ov, W, H - ov), VisualBmp.Canvas, + MakeRect (BORDER_W, BORDER_H + ov, W, H - ov)); + end + else + begin + Inc (x, OfsX); + Inc (y, OfsY); + + while x > 0 do + Dec (x, W); + while y > -ov do + Dec (y, H - ov); + + repeat + i := 0; + repeat + if ov > 0 then + Draw (x + i, y, TmpBmp); + Pattern.Canvas.CopyRect (MakeRect (x + i, y + ov, W, H - ov), + VisualBmp.Canvas, MakeRect (BORDER_W, BORDER_H + ov, W, H - ov)); + + Inc (i, W); + until x + i >= Pattern.Width; + Inc (y, H - ov); + until y >= Pattern.Height; + end; + end; + + Tile.Picture.Graphic := VisualBmp; + + // with TileTab[Tab.TabIndex].tbr do + // Tile.Canvas.Rectangle (Current * W, 0, Current * W + W, H); + + + TmpBmp.Free; + + with TileTab[Tab.TabIndex] do + begin + lastscale := Scale; + lastscrollpos := TileScrollBox.HorzScrollBar.Position; + BackGrColor := Background.Brush.Color; + end; + end; + + UpdateTileGrid; + +end; { UpdateBMP } + +procedure TMainForm.SetTileSize (Width, Height: Integer); + var + BW, BH: Integer; + i, j: Integer; +begin + // StatusBar.Panels[0].Text := Format ('Size: %d x %d', [Width, Height]); + W := Width; + H := Height; + with CursorImage do + begin + Picture.Bitmap.PixelFormat := pf24bit; + Picture.Bitmap.TransparentColor := clRed; + Picture.Bitmap.Transparent := True; + Width := W; + Height := H + 1; + Picture.Bitmap.Width := W; + Picture.Bitmap.Height := H + 1; + with Canvas do + begin + Brush.Color := clRed; // transparent color for cursor + Brush.Style := bsSolid; + Pen.Color := clRed; + Pen.Style := psSolid; + Rectangle (0, 0, W + 1, H + 2); + end; + end; + BW := W + 2 * BORDER_W; + BH := H + 2 * BORDER_H; + with Bmp do + begin + Width := BW; + Height := BH; + Transparent := TRUE; + TransparentMode := tmFixed; + TransparentColor := TRANS_COLOR; + with Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := TRANS_COLOR; + Pen.Style := psClear; + FillRect (Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H)); + Pen.Style := psSolid; + Pen.Color := Color.Brush.Color; + end; + end; + with TempBmp do + begin + Width := BW; + Height := BH; + end; + with VisualBmp do + begin + Width := BW; + Height := BH; + end; + with OnionSkinBmp do + begin + Width := BW; + Height := BH; + end; + + bmp1.Width := BW; + bmp1.Height := BH; + ResizeBitmap (bmp1); + + bmp2.Width := BW; + bmp2.Height := BH; + ResizeBitmap (bmp2); + + SelBmp.Width := BW; + SelBmp.Height := BH; + ResizeBitmap (SelBmp); + FillBitmap (SelBmp, TRANS_COLOR); + for j := 0 to BH - 1 do + for i := 0 to BW - 1 do + case (i + j) mod 8 of + 0: SelBmp.Picture.Bitmap.Canvas.Pixels[i, j] := clYellow; + 4: SelBmp.Picture.Bitmap.Canvas.Pixels[i, j] := clWhite; + end; + + UpdateBmp (TRUE); +end; + + +procedure TMainForm.SetFromTo (N: Integer); + var + R, G, B, iR, iG, iB, RR, GG, BB: Integer; + C, i, j: Integer; +begin + C := Color.Brush.Color; + GetRGB (C, R, G, B); + i := (255 div (MaxRGB - 1)); + R := R div i; + G := G div i; + B := B div i; + + if Pal256 and (FromToCount = -1) then + begin + j := Row256 * 8; + for i := 0 to MAX_FROM_TO - 1 do + begin + if i = MAX_FROM_TO - 1 then Dec (j); + GetRGB (PaletteValues[j + i], iR, iG, iB); + ExFromToList[i, 0] := iR; + ExFromToList[i, 1] := iG; + ExFromToList[i, 2] := iB; + FromToList[i] := PaletteValues[j + i]; + FromToFirst := Index256 mod 8; + FromToLast := Index256 mod 8; + end; + end + else + begin + case FromToCount mod 12 of + 1: begin RR := 3; GG := 3; BB := 3; end; + 2: begin RR := 2; GG := 2; BB := 2; end; + 3: begin RR := 2; GG := 2; BB := 1; end; + 4: begin RR := 1; GG := 2; BB := 2; end; + 5: begin RR := 2; GG := 1; BB := 2; end; + 6: begin RR := 2; GG := 1; BB := 1; end; + 7: begin RR := 1; GG := 2; BB := 1; end; + 8: begin RR := 1; GG := 1; BB := 2; end; + 9: begin RR := 2; GG := 2; BB := 4; end; + 10: begin RR := 4; GG := 2; BB := 2; end; + 11: begin RR := 2; GG := 4; BB := 2; end; + else begin RR := 4; GG := 4; BB := 4; end; + end; + + j := MAX_FROM_TO div 2; + + for i := -j to MAX_FROM_TO - j - 1 do + begin + iR := (256 div (MaxB - 1)) * (R + (RR * i) div 2); + iG := (256 div (MaxB - 1)) * (G + (GG * i) div 2); + iB := (256 div (MaxB - 1)) * (B + (BB * i) div 2); + ExFromToList[j + i, 0] := iR; + ExFromToList[j + i, 1] := iG; + ExFromToList[j + i, 2] := iB; + iR := LimitRGB (iR); + iG := LimitRGB (iG); + iB := LimitRGB (iB); + iR := ColorMatch (iR); + iG := ColorMatch (iG); + iB := ColorMatch (iB); + if (j + i) in [0..MAX_FROM_TO] then + FromToList[j + i] := RGB (LimitRGB (iR), LimitRGB (iG), LimitRGB (iB)); + end; + end; + + FromTo.Repaint; +end; + +procedure TMainForm.SetColor (NewColor: Integer; SetFT: Boolean; AddFT: Boolean); + var + i: Integer; + Found: Boolean; +begin + Background.Pen.Style := psClear; + Erasing := FALSE; + ShiftErasing := FALSE; + + if AddFT then + SetFT := FALSE; + + // don't remove palette when selecting a color with right mouse button + if UsedColors.Visible then + begin + Found := FALSE; + // is the new color in the palette? + with UsedColorsImage.Picture.Bitmap do + for i := 0 to Height - 1 do + if Canvas.Pixels[0, i] = NewColor then + Found := TRUE; + SetFT := not Found; + end; + + if SetFT then + begin + ShowRGB (NewColor); + if Color.Brush.Color <> NewColor then + FromToCount := 0 - Byte (Pal256); + FromToFirst := MAX_FROM_TO div 2; + FromToLast := MAX_FROM_TO div 2; + if FromToCount > 0 - Byte (Pal256) then + begin + FromToFirst := 0; + FromToLast := MAX_FROM_TO - 1; + end; + + HideUsedColors; // the new color is not in the palette + end; + Color.Pen.Style := psSolid; + Color.Brush.Color := NewColor; + + Bmp.Canvas.Pen.Color := NewColor; + DrawColor := NewColor; + FillColor := NewColor; + + if AddFT then // 2.51 - add colors to FT list + begin + if (FromToFirst = MAX_FROM_TO div 2) and + (FromToLast = MAX_FROM_TO div 2) then + begin + FromToFirst := MAX_FROM_TO - 1; + FromToLast := MAX_FROM_TO - 1; + FromToList[FromToFirst] := NewColor; + FromTo.Repaint; + end + else + if FromToFirst <= FromToLast then + if FromToList[FromToFirst] <> NewColor then + begin + if FromToFirst = 0 then + begin + if FromToLast < MAX_FROM_TO - 1 then + begin + Inc (FromToLast); + for i := MAX_FROM_TO - 1 downto FromToFirst + 1 do + FromToList[i] := FromToList[i - 1]; + end; + end + else + Dec (FromToFirst); + + FromToList[FromToFirst] := NewColor; + FromTo.Repaint; + end; + end; + + if SetFT then + begin + SetFromTo (FromToCount); + + i := FindCurrentColorPattern (NewColor, FALSE); + if i = -1 then + i := FindCurrentColorPattern (NewColor, TRUE); + Found := i > -1; + if Found then + begin + FromToSavePos := i; + SelectSavedFromToList; + + if FindCurrentColorPattern (NewColor, FALSE) = -1 then // to set the selection + FindCurrentColorPattern (NewColor, TRUE); + FromToPaint (nil); + end; + end; +end; + +procedure TMainForm.SetBackgroundColor (NewColor: Integer; Select: Boolean); +begin + if Select then + begin + ShowRGB (NewColor); + Background.Pen.Style := psSolid; + Color.Pen.Style := psClear; + + Bmp.Canvas.Pen.Color := TRANS_COLOR; + DrawColor := TRANS_COLOR; + FillColor := TRANS_COLOR; + + Erasing := TRUE; + end; + + TileTab[Tab.TabIndex].tbr.BackGr := NewColor; + + if UsedColors.Visible then + UsedColorsImage.Picture.Bitmap.Canvas.Pixels[0, 0] := NewColor; + + Background.Brush.Color := NewColor; +// TileScrollBox.Color := NewColor; + UpdateBmp (TRUE); + +{ + Tile.Color := NewColor; + DrawingBoard.Brush.Color := NewColor; +} + pBack.Color := BackGround.Brush.Color; + pMid.Color := BackGround.Brush.Color; + pFront.Color := BackGround.Brush.Color; + + UpdateTileBitmap; + Modified := TRUE; +end; + +procedure TMainForm.RearrangePalette1Click(Sender: TObject); +begin + PaletteOrder := (PaletteOrder + 1) mod MAX_PALETTE_ORDER; + Palette.Repaint; +end; + +procedure TMainForm.FromToPaint(Sender: TObject); + var + i, j, k, W, Y1, Y2, Y3, AH: Integer; + Split: Boolean; +begin + Split := SplitColorPattern1.Checked; + W := FromTo.Width div MAX_FROM_TO; + Y1 := 6; + Y2 := 20 - 4 * Byte (Split); + Y3 := 22; + AH := 2; + with FromTo.Canvas do + begin + Brush.Style := bsSolid; + for i := 0 to MAX_FROM_TO - 1 do + begin + Brush.Color := FromToList[i]; + Pen.Style := psClear; + Rectangle (i * W, Y1, (i + 1) * W + 1, Y2); + if Split then + begin + Brush.Color := OtherFromTo.FT[i]; + Rectangle (i * W, Y2, (i + 1) * W + 1, Y3); + end; + end; + Pen.Style := psSolid; + Brush.Style := bsClear; + Pen.Color := FromToPanel.Color; + Rectangle (0, AH, MAX_FROM_TO * W, AH + 1); + Pen.Color := clBlack; + i := FromToFirst * W; + j := FromToLast * W; + k := j + W - 2; + if i > j then + begin + j := FromToFirst * W; + i := FromToLast * W; + k := i + 2; + end; + Rectangle (i, AH, j + W, AH + 1); + if FromToFirst <> FromToLast then + Rectangle (k, AH - 1, k + 1, AH + 2); + end; + i := (FromToFirst + 1) * Byte (FromToFirst = FromToLast); + ToggleMultiple1.Checked := i = 0; + N_1.Checked := i = 1; + N_2.Checked := i = 2; + N_3.Checked := i = 3; + N_4.Checked := i = 4; + N_5.Checked := i = 5; + N_6.Checked := i = 6; + N_7.Checked := i = 7; + N_8.Checked := i = 8; + N_9.Checked := i = 9; +end; + +procedure TMainForm.FromToMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + W: Integer; +begin + W := FromTo.Width div MAX_FROM_TO; + if Button = mbLeft then + begin + FromToSelect := TRUE; + FromToFirst := X div W; + FromToLast := FromToFirst; + end; + if Button = mbRight then + FromToBackgroundSelect := TRUE; + FromToMouseMove (Sender, Shift, X, Y); +end; + +procedure TMainForm.FromToMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + var + W, n, k: Integer; +begin + W := FromTo.Width div MAX_FROM_TO; + n := X div W; + if (n >= 0) and (n < MAX_FROM_TO) then + begin + k := FromToList[n]; + ShowRGB (k); + if FromToSelect then + begin + SetColor (k, FALSE, FALSE); + FromToLast := X div W; + if FromToLast < 0 then + FromToLast := 0; + if FromToLast >= MAX_FROM_TO then + FromToLast := MAX_FROM_TO - 1; + FromTo.Repaint; + { + if (FromToSavePos < Length (FromToSave)) then + begin + FromToSave[FromToSavePos].F := FromToFirst; + FromToSave[FromToSavePos].L := FromToLast; + end; + } + end; + if FromToBackgroundSelect then + SetBackgroundColor (k, FALSE); + end; +end; + +procedure TMainForm.FromToMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + FromToSelect := FALSE; + if Button = mbRight then + FromToBackgroundSelect := FALSE; +end; + +procedure TMainForm.ColorMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + if Erasing then + SetColor (Color.Brush.Color, TRUE, FALSE) + else + begin + ColorDialog.Color := Color.Brush.Color; + if ColorDialog.Execute then + begin + ColorSelect := FALSE; + SetColor (ColorDialog.Color, FALSE, FALSE); + end; + ShowRGB (ColorDialog.Color); + end; + if Button = mbRight then + SetColor (ColorMatch (Color.Brush.Color), TRUE, FALSE); +end; + +procedure TMainForm.ZoomIn1Click(Sender: TObject); +begin + if Mode = mTile then + if Scale < MAX_SCALE then + begin + Inc (Scale); + MainForm.Resize; + end; + if Mode = mMap then + if Zoom > 1 then + begin + Dec (Zoom); + ZoomMap; + UpdateMap; + end; + if TileSelection.Visible then + ShowTileSelection (TRUE); +end; + +procedure TMainForm.ZoomOut1Click(Sender: TObject); +begin + if Mode = mTile then + if Scale > 1 then + begin + Dec (Scale); + MainForm.Resize; + end; + if Mode = mMap then + if Zoom < MAX_ZOOM then + begin + Inc (Zoom); + ZoomMap; + UpdateMap; + end; + if TileSelection.Visible then + ShowTileSelection (TRUE); +end; + +function IntStr (x: Integer): string; + var + bin: array[0..SizeOf (Integer) - 1] of Char absolute x; + s: string; + i: Integer; +begin + s := ''; + for i := 0 to SizeOf (Integer) - 1 do + s := s + bin[i]; + IntStr := s; +end; + +function StrInt (s: string): Integer; + var + x: Integer; + bin: array[0..SizeOf (Integer) - 1] of Char absolute x; + i: Integer; +begin + for i := 0 to SizeOf (Integer) - 1 do + bin[i] := s[i + 1]; + StrInt := x; +end; + +function ActName (dt: TDrawingTool): string; +begin + case dt of + dtBrush: ActName := 'Brush'; + dtLine: ActName := 'Line'; + dtRect, + dtFilledRect: ActName := 'Rectangle'; + dtRoundRect, + dtFilledRoundRect: ActName := 'Round Rectangle'; + dtEllipse, + dtFilledEllipse: ActName := 'Ellipse'; + dtFill: ActName := 'Flood Fill'; + else + ActName := 'Drawing'; + end; +end; + +procedure TMainForm.TileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + xp, yp: Integer; +begin + Busy := TRUE; + LastShift := Shift; + LastButton := Button; + GradientH := FALSE; + GradientV := FALSE; + GradientD := FALSE; + + Horizontal3.Enabled := TRUE; + Vertical3.Enabled := TRUE; + Diagonal1.Enabled := TRUE; + Horizontal3.Checked := FALSE; + Vertical3.Checked := FALSE; + Diagonal1.Checked := FALSE; + + LastX := X; + LastY := Y; + ShiftState := Shift; + xp := X div Scale; + yp := Y div Scale; + if (Button = mbLeft) then + begin + if DrawingTool in FirstSaveUndoTools then + SaveUndo (ActName (DrawingTool)); + if (ssShift in ShiftState) or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down then + SaveTempBmp; + Drawing := TRUE; + LineList := ''; + Bmp.Canvas.MoveTo (xp, yp); + Origin := Point (xp, yp); + CurPos := Origin; + OrigColor := Bmp.Canvas.Pixels[xp, yp]; + Bmp.Canvas.Pen.Color := DrawColor; + if Bmp.Canvas.Brush.Style = bsSolid then + Bmp.Canvas.Brush.Color := FillColor; + Modified := TRUE; + end; + if Button = mbRight then + if (ssShift in ShiftState) then + begin + SaveUndo ('Erase'); + ShiftErasing := TRUE; + Bmp.Canvas.MoveTo (xp, yp); + Origin := Point (xp, yp); + CurPos := Origin; + Bmp.Canvas.Pen.Color := TRANS_COLOR; + Modified := TRUE; + end + else + ReadingColor := TRUE; + if not (Erasing or ShiftErasing) then + if (ssShift in ShiftState) or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down then + begin + if DarkButton.Down then + SpecialColor := SPECIAL_COLOR1 + else + if LightButton.Down then + SpecialColor := SPECIAL_COLOR2 + else + SpecialColor := $FFFFFF - BackGround.Brush.Color and $FFFFFF; + Bmp.Canvas.Pen.Color := SpecialColor; + if Bmp.Canvas.Brush.Style = bsSolid then + Bmp.Canvas.Brush.Color := SpecialColor; + end; + TileMouseMove (Sender, Shift, X, Y); + Busy := FALSE; +end; + +procedure TMainForm.TileMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + i, j, k, l, m, n, o, p, xx, yy: Integer; + R, G, B, RR, GG, BB: Integer; + cm: Boolean; + Ex: Boolean; + RX, RY, NS: Real; + RndX, RndY: Integer; + +begin + Busy := TRUE; + LastShift := Shift; + LastButton := Button; + LastX := X; + LastY := Y; + Ex := FALSE; + if Button = mbLeft then + if Drawing then + begin + if not (DrawingTool in FirstSaveUndoTools) then + SaveUndo (ActName (DrawingTool)); + DrawFTShape (Origin.X, Origin.Y, CurPos.X, CurPos.Y, Bmp.Canvas); + SaveHistoryCoords (Origin.X - BORDER_W, Origin.Y - BORDER_H, CurPos.X - BORDER_W, CurPos.Y - BORDER_H); + Undo[UndoPos].HistoryCoords := HistoryListBox.Items[HistoryListBox.Items.Count - 1]; // 3.00 + AddColorPattern1Click (Sender); + Drawing := FALSE; + end; + if Button = mbRight then + begin + ReadingColor := FALSE; + ShiftErasing := FALSE; + end; + if (ssShift in ShiftState) or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down then + begin + l := 256 div (MaxRGB - 1); + + // NoiseSizeX := W div LineTool.Height; // 2.43 + // NoiseSizeY := H div LineTool.Height; + // if NoiseSizeX < 2 then NoiseSizeX := 2; + // if NoiseSizeY < 2 then NoiseSizeY := 2; + RndX := Random (1000); + RndY := Random (1000); + + if RandomButton.Down then + begin + for j := BORDER_H - 1 to BORDER_H + H + 1 do + for i := BORDER_W - 1 to BORDER_W + W + 1 do + with TempBmp.Canvas do + begin + RX := RndX + i * (15 - LineTool.Height); + RY := RndY + j * (15 - LineTool.Height); + NS := Noise2 (RX / W, RY / H); + + n := Abs (FromToLast - FromToFirst); + m := Byte (FromToLast > FromToFirst) - Byte (FromToFirst > FromToLast); + k := Pixels[i, j]; + if (n = 0) xor (ssCtrl in ShiftState) then + begin + if k <> TRANS_COLOR then + begin + GetRGB (k, R, G, B); + if ssShift in ShiftState then + begin + if UseOldNoiseFunctions1.Checked then + m := l * (Random (3) - 1) + else + m := Round (System.Int (l * (2 * NS - 1))) + end + else + m := 0; { smooth } + Pixels[i, j] := RGB (LimitRGB (R + m), LimitRGB (G + m), LimitRGB (B + m)); + end; + end + else + // Pixels[i, j] := FromToList[FromToFirst + m * Random (n + 1)]; + begin + Ex := TRUE; + if UseOldNoiseFunctions1.Checked then + p := FromToFirst + m * Random (n + 1) + else + p := Round (System.Int (FromToFirst + m * NS * (n + 1))); + R := ExFromToList[p, 0] div 4 + 96; + G := ExFromToList[p, 1] div 4 + 96; + B := ExFromToList[p, 2] div 4 + 96; + Pixels[i, j] := RGB (LimitRGB (R), LimitRGB (G), LimitRGB (B)); + end; + end; + end; + + for j := BORDER_H to BORDER_H + H do + for i := BORDER_W to BORDER_W + W do + begin + k := Bmp.Canvas.Pixels[i, j]; + if k = SpecialColor then + begin + k := TempBmp.Canvas.Pixels[i, j]; + if RandomButton.Down then + begin + if k <> TRANS_COLOR then + begin + n := 2 + 6 * Byte ((ssAlt in ShiftState) or (RealTimeLightening1.Checked)); + o := n; + GetRGB (k, RR, GG, BB); + RR := n * RR; + GG := n * GG; + BB := n * BB; + + for n := -1 to 1 do + for m := -1 to 1 do + begin + xx := i + m; + yy := j + n; + if xx < BORDER_W then + Inc (xx, W) + else if xx >= W + BORDER_W then + Dec (xx, W); + if yy < BORDER_H then + Inc (yy, H) + else if yy >= H + BORDER_H then + Dec (yy, H); + p := TempBmp.Canvas.Pixels[xx, yy]; + if p <> TRANS_COLOR then + begin + GetRGB (p, R, G, B); + Inc (RR, R); + Inc (GG, G); + Inc (BB, B); + Inc (o); + end; + end; + RR := RR div o; + GG := GG div o; + BB := BB div o; + if Ex then + begin + RR := (RR - 96) * 4; + GG := (GG - 96) * 4; + BB := (BB - 96) * 4; + end; + R := LimitRGB (RR); + G := LimitRGB (GG); + B := LimitRGB (BB); + k := RGB (R, G, B); + end; + end + else + begin + if k = TRANS_COLOR then + k := DrawColor + else + begin + if PlusButton.Down then + begin + if (ssAlt in ShiftState) or (RealTimeLightening1.Checked) then + k := ColorBetween (k, ColorBetween (k, ColorBetween (k, Color.Brush.Color))) + else + k := ColorBetween (k, Color.Brush.Color); + end + else + begin + p := 1 + 5 * Byte ((ssAlt in ShiftState) or (RealTimeLightening1.Checked)); + cm := k = ColorMatch (k); + GetRGB (k, R, G, B); + if LightButton.Down then + k := RGB (LimitRGB (R + l div p), LimitRGB (G + l div p), LimitRGB (B + l div p)) + else + k := RGB (LimitRGB (R - l div p), LimitRGB (G - l div p), LimitRGB (B - l div p)); + if cm and (p = 1) then + k := ColorMatch (k); + end; + end; + end; + Bmp.Canvas.Pixels[i, j] := k; + end; + end; + end; + + Horizontal3.Checked := FALSE; + Vertical3.Checked := FALSE; + Diagonal1.Checked := FALSE; + Horizontal3.Enabled := FALSE; + Vertical3.Enabled := FALSE; + Diagonal1.Enabled := FALSE; + + UpdateBmp (TRUE); + Busy := FALSE; +end; + +procedure TMainForm.TileMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + var + xp, yp, c: Integer; + i, j, k, l: Integer; +begin + Busy := TRUE; + LastShift := Shift; + LastX := X; + LastY := Y; + xp := X div Scale; + yp := Y div Scale; + + i := xp - BORDER_W; + j := yp - BORDER_H; + if (i >= 0) and (i < W) and + (j >= 0) and (j < H) then + ShowRGB (Bmp.Canvas.Pixels[xp, yp]) + else + ShowRGB (TRANS_COLOR); + + StatusBar.Panels[1].Text := Format ('(%d, %d)', [i, j]); + ShowOrigin := Drawing and (DrawingTool in [dtLine, dtRect, + dtRoundRect, dtEllipse, dtFilledRect, + dtFilledRoundRect, dtFilledEllipse, dtSelection]); + if ShowOrigin then + begin + k := Origin.x - BORDER_W; + l := Origin.y - BORDER_H; + StatusBar.Panels[1].Text := Format ('(%d, %d)-', [k, l]) + + StatusBar.Panels[1].Text + + Format (' [%d, %d]', [Abs (k - i), Abs (l - j)]); // 2.5 + end; + + if ReadingColor then + begin + { i := FromToFirst; + j := FromToLast; } + c := Bmp.Canvas.Pixels[xp, yp]; + if c = TRANS_COLOR then + SetBackgroundColor (Background.Brush.Color, TRUE) + else + begin + SetColor (c, TRUE, ssCtrl in LastShift); + { + if ssCtrl in LastShift then + begin + FromToFirst := i; // 2.2 + FromToLast := j; + FromToPaint (Sender); + end; } // 2.51 - removed, now use Ctrl to add to FT selection + end; + end; + + if Drawing then + begin + case DrawingTool of + dtFill: + begin + for i := -1 to W do + begin + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H - 1] := TRANS_COLOR; + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + H] := TRANS_COLOR; + end; + for j := -1 to H do + begin + Bmp.Canvas.Pixels[BORDER_W - 1, BORDER_H + j] := TRANS_COLOR; + Bmp.Canvas.Pixels[BORDER_W + W, BORDER_H + j] := TRANS_COLOR; + end; + + if ssCtrl in LastShift then // 2.53 - replace color in tile + begin + k := Bmp.Canvas.Pixels[xp, yp]; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + if Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] = k then + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := Bmp.Canvas.Pen.Color; + end + else + Bmp.Canvas.FloodFill (xp, yp, Bmp.Canvas.Pixels[xp, yp], fsSurface); + end; + dtPoint: + begin + Bmp.Canvas.Pixels[xp, yp] := Bmp.Canvas.Pen.Color; + Bmp.Canvas.LineTo (xp, yp); + CurPos := Point (xp, yp); + end; + dtBrush: + begin + if (ssAlt in ShiftState) or (FromToFirst = FromToLast) then + begin + Bmp.Canvas.Pixels[xp, yp] := Bmp.Canvas.Pen.Color; + Bmp.Canvas.LineTo (xp, yp); + end + else + DrawFTCircle (BMP.Canvas, xp, yp, ssShift in ShiftState); + if DrawingTool = dtBrush then + if (CurPos.x <> xp) or (CurPos.y <> y) or (LineList = '') then + LineList := LineList + IntStr (xp) + IntStr (yp); + CurPos := Point (xp, yp); + end; + else + begin + CurPos := Point (xp, yp); + DrawingShape := TRUE; + end; + end; + UpdateBmp (FALSE); + end; + if ShiftErasing then + begin + Bmp.Canvas.Pixels[xp, yp] := TRANS_COLOR; + Bmp.Canvas.LineTo (xp, yp); + CurPos := Point (xp, yp); + UpdateBmp (FALSE); + end; + Busy := FALSE; +end; + +procedure TMainForm.ShowTileSelection (Clip: Boolean); + var + X1, Y1, X2, Y2: Integer; +begin + X1 := TileSelX1; + Y1 := TileSelY1; + X2 := TileSelX2; + Y2 := TileSelY2; + + if Clip then + begin + if X1 - BORDER_W < 0 then X1 := BORDER_W; + if Y1 - BORDER_H < 0 then Y1 := BORDER_H; + if X2 - BORDER_W > W then X2 := W + BORDER_W; + if Y2 - BORDER_H > H then Y2 := H + BORDER_H; + + if X2 - BORDER_W < 0 then X2 := BORDER_W; + if Y2 - BORDER_H < 0 then Y2 := BORDER_H; + if X1 - BORDER_W > W then X1 := W + BORDER_W; + if Y1 - BORDER_H > H then Y1 := H + BORDER_H; + + TileSelX1 := X1; + TileSelY1 := Y1; + TileSelX2 := X2; + TileSelY2 := Y2; + end; + + with TileSelection do + begin + Left := X1 * Scale + Tile.Left; + Top := Y1 * Scale + Tile.Top; + Width := (X2 - X1) * Scale; + Height := (Y2 - Y1) * Scale; + Visible := TRUE; + end; +end; + + +procedure TMainForm.SwapInt (var x, y: Integer); + var + i: Integer; +begin + i := x; + x := y; + y := i; +end; + +function TMainForm.ColorPerc (RGB1, RGB2, Perc2, MaxPerc: Integer): Integer; + var + R1, G1, B1: Integer; + R2, G2, B2: Integer; + C: Integer; + Perc1: Integer; +begin + GetRGB (RGB1, R1, G1, B1); + GetRGB (RGB2, R2, G2, B2); + Perc1 := MaxPerc - Perc2; + C := MakePalRGB ((R1 * Perc1 + R2 * Perc2) div MaxPerc, + (G1 * Perc1 + G2 * Perc2) div MaxPerc, + (B1 * Perc1 + B2 * Perc2) div MaxPerc, 0); + ColorPerc := C; +end; + +function TMainForm.ColorPercFT (i1, i2, Perc2, MaxPerc: Integer): Integer; + var + Perc1: Integer; + N: Integer; + c1, c2, p1, p2: Integer; +begin + Perc1 := MaxPerc - Perc2; + if i1 > i2 then + begin + SwapInt (i1, i2); + SwapInt (Perc1, Perc2); + end; + Inc (Perc1); // 2.43 bug fix: range check error + + // MainForm.Caption := Format (' %d %d %d %d %d ', [i1, i2, perc1, perc2, maxperc]); + + N := i2 - i1; + c1 := i1 + N * Perc2 div MaxPerc; + c2 := c1 + 1; + p1 := (100 * N * Perc2 div MaxPerc) mod 100; + p2 := 100; + if (c1 < Low (FromToList)) then + c1 := Low (FromToList); + if (c2 > High (FromToList)) then + c2 := High (FromToList); + ColorPercFT := ColorPerc (FromToList[c1], FromToList[c2], p1, p2); +end; + +procedure TMainForm.DrawFTShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + var + i, j, k, l, M, N, o, p, x, y: Integer; + oi, pi: Integer; + OrigX1, OrigX2, OrigY1, OrigY2: Integer; + sh, alt, ctrl: Boolean; + found: Boolean; + OColor: Integer; + +begin + OrigX1 := X1; + OrigX2 := X2; + OrigY1 := Y1; + OrigY2 := Y2; + sh := ssShift in ShiftState; + alt := ssAlt in ShiftState; + ctrl := ssCtrl in ShiftState; + + if DrawingTool in [dtRect, dtRoundRect, dtEllipse, + dtFilledRect, dtFilledRoundRect, dtFilledEllipse] then + begin + if X2 >= X1 then Inc (X2) else Inc (X1); + if Y2 >= Y1 then Inc (Y2) else Inc (Y1); + end; + + with TileSelection do + if (DrawingTool in [dtSelection]) and + (not ((X1 = X2) and (Y1 = Y2))) then + begin + if X1 > X2 then begin i := X1; X1 := X2; X2 := i; end; + if Y1 > Y2 then begin i := Y1; Y1 := Y2; Y2 := i; end; + TileSelX1 := X1; + TileSelY1 := Y1; + TileSelX2 := X2; + TileSelY2 := Y2; + ShowTileSelection (TRUE); + end + else + Visible := FALSE; + + N := Byte (FromToLast > FromToFirst) - + Byte (FromToLast < FromToFirst); + if Erasing or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down or + (N = 0) or + (not (DrawingTool in [dtPoint, + dtBrush, + dtFilledRect, + dtFilledRoundRect, + dtFilledEllipse])) then + DrawShape (X1, Y1, X2, Y2, C) + else + begin + if X1 > X2 then begin i := X1; X1 := X2; X2 := i; end; + if Y1 > Y2 then begin i := Y1; Y1 := Y2; Y2 := i; end; + i := FromToFirst; + + if (DrawingTool in [dtPoint, dtBrush]) and Alt then { *** } + begin + M := Length (LineList) div (2 * SizeOf (Integer)); + + for j := 0 to M - 1 do + begin + + if SmoothPalette1.Checked then + begin + if Ctrl then + begin + OColor := OrigColor; + if OColor = TRANS_COLOR then + OColor := Background.Brush.Color; // 2.43 + o := ColorPerc (OColor, FromToList[FromToLast], j, M); + end + else + begin + oi := FromToFirst; + pi := FromToLast; + o := ColorPercFT (oi, pi, j, M); + end; + end + else + begin + if M - 1 = 0 then + i := FromToLast + else + i := FromToFirst + (j * Abs (FromToLast - FromToFirst) div (M - 1)) * N; + o := FromToList[i]; + end; + + C.Pen.Color := o; + C.Brush.Color := o; + + x := StrInt (Copy (LineList, 1, SizeOf (Integer))); + Delete (LineList, 1, SizeOf (Integer)); + y := StrInt (Copy (LineList, 1, SizeOf (Integer))); + Delete (LineList, 1, SizeOf (Integer)); + if j = 0 then + C.MoveTo (x, y) + else + C.LineTo (x, y); + end; + + end + else + if Ctrl or GradientH or GradientV or GradientD then + begin + if not (GradientH or GradientV or GradientD) then + GradientD := TRUE; + + SaveTempBmp; + + with TempBmp.Canvas do + begin + Pen.Color := SpecialColor; + Brush.Color := SpecialColor; + end; + + DrawShape (X1, Y1, X2, Y2, TempBmp.Canvas); + + k := 0; + l := 1; + for y := Y1 - 1 to Y2 + 1 do + for x := X1 - 1 to X2 + 1 do + begin + if TempBmp.Canvas.Pixels[x, y] = SpecialColor then + begin + TempBmp.Canvas.Pixels[x, y] := C.Pixels[x, y]; + if Ctrl then + begin + oi := -1; + o := C.Pixels[x, y]; + if o = TRANS_COLOR then + o := BackGround.Brush.Color; + end + else + begin + oi := FromToFirst; + o := FromToList[oi]; + end; + pi := FromToLast; + p := FromToList[pi]; + if GradientH then + begin + k := x - X1; + l := X2 - X1; + end; + if GradientV then + begin + k := y - Y1; + l := Y2 - Y1; + end; + if GradientD then + begin + if OrigX1 > OrigX2 then + k := Abs (X2 - x) + else + k := Abs (x - X1); + if OrigY1 > OrigY2 then + Inc (k, Abs (Y2 - y)) + else + Inc (k, Abs (y - Y1)); + l := Abs (X2 - X1) + Abs (Y2 - Y1); + end; + if (GradientH and (OrigX1 > OrigX2)) or + (GradientV and (OrigY1 > OrigY2)) then + begin + SwapInt (oi, pi); + SwapInt (o, p); + end; + if (oi >= 0) and (pi >= 0) then + begin + C.Pixels[x, y] := ColorPercFT (oi, pi, Abs (k), Abs (l)); + end + else + C.Pixels[x, y] := ColorPerc (o, p, Abs (k), Abs (l)); + end; + end; + + + end + else + repeat { draw filled shape (outside -> inside) } + if sh then + begin + C.Pen.Color := SpecialColor; + C.Brush.Color := SpecialColor; + SaveTempBmp; + end + else + begin + C.Pen.Color := FromToList[i]; + C.Brush.Color := FromToList[i]; + end; + DrawShape (X1, Y1, X2, Y2, C); + + if sh then + begin + for y := Y1 - LineTool.Height to Y2 + LineTool.Height do // 2.44 + for x := X1 - LineTool.Height to X2 + LineTool.Height do + begin + if Bmp.Canvas.Pixels[x, y] = SpecialColor then + begin + found := FALSE; + k := i; + repeat + if TempBmp.Canvas.Pixels[x, y] = FromToList[k] then + found := TRUE; + k := k + N; + until ((N < 0) and (k - N = 0)) + or ((N > 0) and (k - N = MAX_FROM_TO - 1)); + if not Found then + Bmp.Canvas.Pixels[x, y] := FromToList[i] + else + Bmp.Canvas.Pixels[x, y] := TempBmp.Canvas.Pixels[x, y]; + end; + + end; + end; + + // 2.44 + if not ((XShade < 0) and (i mod (3 - Abs (XShade)) = 0)) then + Inc (X1, LineTool.Height); + if not ((YShade < 0) and (i mod (3 - Abs (YShade)) = 0)) then + Inc (Y1, LineTool.Height); + if not ((XShade > 0) and (i mod (3 - Abs (XShade)) = 0)) then + Dec (X2, LineTool.Height); + if not ((YShade > 0) and (i mod (3 - Abs (YShade)) = 0)) then + Dec (Y2, LineTool.Height); + i := i + N; + until (X1 >= X2) or (Y1 >= Y2) or (i - N = FromToLast); + C.Pen.Color := Color.Brush.Color; + C.Brush.Color := Color.Brush.Color; + end; +end; + +procedure TMainForm.DrawFTCircle (C: TCanvas; xp, yp: Integer; Shift: Boolean); + var + x, y, x1, y1, x2, y2: Integer; + d: Real; + N: Integer; + i, k: Integer; + Found: Boolean; +begin + N := Byte (FromToLast > FromToFirst) - + Byte (FromToLast < FromToFirst); + + x1 := xp - C.Pen.Width; + y1 := yp - C.Pen.Width; + x2 := xp + C.Pen.Width; + y2 := yp + C.Pen.Width; + + for y := Y1 to Y2 do + for x := X1 to X2 do + begin + d := 1 + (Sqrt (Sqr (x - xp) + Sqr (y - yp))); + if d < (C.Pen.Width + 1) then + begin + d := 1 + (Sqrt (Sqr (x - xp - XShade) + Sqr (y - yp - YShade))); // 2.44 + if d > C.Pen.Width then + d := C.Pen.Width; + i := FromToFirst + N * (C.Pen.Width - Round (System.Int (d))); + if ((N < 0) and (i < FromToLast)) or + ((N > 0) and (i > FromToLast)) then + i := FromToLast; + + Found := FALSE; + k := i; + if N <> 0 then + repeat + if C.Pixels[x, y] = FromToList[k] then + Found := TRUE; + k := k + N; + until ((N < 0) and (k - N <= 0)) + or ((N > 0) and (k - N >= MAX_FROM_TO - 1)); + + if (Shift) or (not Found) then + C.Pixels[x, y] := FromToList[i]; + end; + end; + +end; + +procedure TMainForm.DrawShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + var + DX, DY: Integer; + +begin + with C do + begin + case DrawingTool of + dtLine: + begin + MoveTo (X1, Y1); + LineTo (X2, Y2); + end; + dtRect, + dtFilledRect: + Rectangle (X1, Y1, X2, Y2); + dtRoundRect, + dtFilledRoundRect: + RoundRect (X1, Y1, X2, Y2, + (X1 - X2) div 2, (Y1 - Y2) div 2); + { Polybezier ([Point (X1, Y1), Point (X2, Y1), Point (X2, Y2), Point (X1, Y2)]); } + { Arc (X1, Y1, X2, Y2, curpos.X, curpos.Y, origin.X, origin.Y); } + { + begin + DX := X2 - X1; + DY := Y2 - Y1; + if CurPos.Y > Origin.Y then + if CurPos.X > Origin.X then + Polybezier ([Point (X1, Y1), Point (X2, Y1), Point (X2, Y2), Point (X1, Y1)]) + else + Polybezier ([Point (X2, Y1), Point (X1, Y1), Point (X1, Y2), Point (X2, Y1)]) + else + if CurPos.X > Origin.X then + Polybezier ([Point (X1, Y2), Point (X2, Y2), Point (X2, Y1), Point (X1, Y2)]) + else + Polybezier ([Point (X2, Y2), Point (X1, Y2), Point (X1, Y1), Point (X2, Y2)]) + + end; + } + + + dtEllipse, + dtFilledEllipse: + Ellipse (X1, Y1, X2, Y2); + end; + end; +end; + +procedure TMainForm.SetDrawingTool(Sender: TObject); +begin +{ + if DrawingTool = dtSelection then + begin + SaveUndo ('Drop Selection'); + UpdateBmp (TRUE); + Modified := TRUE; + end; +} + Bmp.Canvas.Brush.Style := bsClear; + + if Sender = SelectionButton then + ShowTileSelection (TRUE) + else + TileSelection.Visible := FALSE; + + if (Sender = PencilButton) or + (Sender = BrushButton) then + Tile.Cursor := crDefault + else + Tile.Cursor := crCross; + + LineSize[DrawingTool] := LineTool.Height; // 2.43 + + if (Sender = LineButton) or + (Sender = RectButton) or + (Sender = RoundRectButton) or + (Sender = EllipseButton) or + (Sender = BrushButton) then + begin + LineTool.Brush.Color := clBlack; + LineTool.Pen.Color := clBlack; + Bmp.Canvas.Pen.Width := LineTool.Height; + VisualBmp.Canvas.Pen.Width := LineTool.Height; + end + else + begin + LineTool.Brush.Color := clGray; + LineTool.Pen.Color := clGray; + Bmp.Canvas.Pen.Width := 1; + VisualBmp.Canvas.Pen.Width := 1; + end; + + if Sender = PencilButton then + DrawingTool := dtPoint + else + begin + if Sender = BrushButton then + DrawingTool := dtBrush + else + if Sender = LineButton then + DrawingTool := dtLine + else + if Sender = RectButton then + DrawingTool := dtRect + else + if Sender = RoundRectButton then + DrawingTool := dtRoundRect + else + if Sender = EllipseButton then + DrawingTool := dtEllipse + else + begin + Bmp.Canvas.Brush.Style := bsSolid; + Bmp.Canvas.Brush.Color := FillColor; + if Sender = FillButton then + DrawingTool := dtFill + else + if Sender = FilledRectButton then + DrawingTool := dtFilledRect + else + if Sender = FilledRoundRectButton then + DrawingTool := dtFilledRoundRect + else + if Sender = FilledEllipseButton then + DrawingTool := dtFilledEllipse + else + if Sender = SelectionButton then + DrawingTool := dtSelection; + end; + end; + + LineTool.Height := LineSize[DrawingTool]; // 2.43 + LineToolMouseDown(nil, mbMiddle, [], 0, 0); +end; + +procedure TMainForm.GetTileArea; +begin + TileAreaX := BORDER_W; + TileAreaY := BORDER_H; + TileAreaW := W; + TileAreaH := H; + if TileSelection.Visible then + begin + TileAreaX := TileSelX1; + TileAreaY := TileSelY1; + TileAreaW := TileSelX2 - TileSelX1; + TileAreaH := TileSelY2 - TileSelY1; + end; +end; + +procedure TMainForm.Up1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + for i := 0 to TileAreaW - 1 do + begin + y := TileAreaY; + k := Pixels[x, y]; + for j := 0 to TileAreaH - 2 do + Pixels[x, y + j] := Pixels[x, y + j + 1]; + Pixels[x, y + TileAreaH - 1] := k; + Inc (x); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.Down1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + for i := 0 to TileAreaW - 1 do + begin + y := TileAreaY; + k := Pixels[x, y + TileAreaH - 1]; + for j := TileAreaH - 1 downto 1 do + Pixels[x, y + j] := Pixels[x, y + j - 1]; + Pixels[x, y] := k; + Inc (x); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.Left1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + y := TileAreaY; + for j := 0 to TileAreaH - 1 do + begin + x := TileAreaX; + k := Pixels[x, y]; + for i := 0 to TileAreaW - 2 do + Pixels[x + i, y] := Pixels[x + i + 1, y]; + Pixels[x + TileAreaW - 1, y] := k; + Inc (y); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.Right1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + y := TileAreaY; + for j := 0 to TileAreaH - 1 do + begin + x := TileAreaX; + k := Pixels[x + TileAreaW - 1, y]; + for i := TileAreaW - 1 downto 1 do + Pixels[x + i, y] := Pixels[x + i - 1, y]; + Pixels[x, y] := k; + Inc (y); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.HFlipBounds; + var + b1, b2: Boolean; +begin + if Bounds <> 0 then + begin + // if Bounds < $10 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + b1 := Bounds and $2 <> 0; + b2 := Bounds and $8 <> 0; + Bounds := Bounds and (not ($2 or $8)); + Bounds := Bounds or ((Byte(b1) shl 3) or (Byte(b2) shl 1)); + end + else + Bounds := Bounds xor 1; + BoundBox.RePaint; + Modified := TRUE; + end; +end; + +procedure TMainForm.RotateBounds (var Bounds: Integer; deg: Integer); // 2.5 + var + b0, b1, b2, b3: Boolean; +begin + if Bounds <> 0 then + begin + // if Bounds < $10 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + b0 := Bounds and $1 <> 0; + b1 := Bounds and $2 <> 0; + b2 := Bounds and $4 <> 0; + b3 := Bounds and $8 <> 0; + Bounds := Bounds and (not ($F)); + if deg > 0 then { rotate left } + Bounds := Bounds or (Byte(b0) shl 1) or (Byte(b1) shl 2) or (Byte(b2) shl 3) or (Byte(b3) shl 0) + else + Bounds := Bounds or (Byte(b0) shl 3) or (Byte(b1) shl 0) or (Byte(b2) shl 1) or (Byte(b3) shl 2); + end + else + Bounds := Bounds xor 1; { diagonal bounds, only 45 degrees so far } + BoundBox.RePaint; + Modified := TRUE; + end; +end; + +procedure TMainForm.Horizontal1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + SaveUndo ('Flip Horizontal'); + GetTileArea; + with Bmp.Canvas do + begin + y := TileAreaY; + for j := 0 to TileAreaH - 1 do + begin + x := TileAreaX; + for i := 0 to TileAreaW div 2 - 1 do + begin + k := Pixels[x + i, y]; + Pixels[x + i, y] := Pixels[x + TileAreaW - 1 - i, y]; + Pixels[x + TileAreaW - 1 - i, y] := k; + end; + Inc (y); + end; + end; + if not TileSelection.Visible then + HFlipBounds (Bounds); + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; +end; + +procedure TMainForm.VFlipBounds; + var + b1, b2: Boolean; +begin + if Bounds <> 0 then + begin + // if Bounds < $10 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + b1 := Bounds and $1 <> 0; + b2 := Bounds and $4 <> 0; + Bounds := Bounds and (not ($1 or $4)); + Bounds := Bounds or ((Byte(b1) shl 2) or (Byte(b2) shl 0)); + end + else + Bounds := Bounds xor 1; + BoundBox.RePaint; + Modified := TRUE; + end; +end; + +procedure TMainForm.Vertical1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + SaveUndo ('Flip Vertical'); + + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + for i := 0 to TileAreaW - 1 do + begin + y := TileAreaY; + for j := 0 to TileAreaH div 2 - 1 do + begin + k := Pixels[x, y + j]; + Pixels[x, y + j] := Pixels[x, y + TileAreaH - 1 - j]; + Pixels[x, y + TileAreaH - 1 - j] := k; + end; + Inc (x); + end; + end; + + if not TileSelection.Visible then + VFlipBounds (Bounds); + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; +end; + +procedure TMainForm.Clear1Click(Sender: TObject); + var + i, j: Integer; + b: Boolean; +begin + SaveUndo ('Clear'); + GetTileArea; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + Bmp.Canvas.Pixels[i + TileAreaX, j + TileAreaY] := TRANS_COLOR; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.LineToolMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + if LineTool.Height < 12 then + LineTool.Height := LineTool.Height + 1; + if Button = mbRight then + if LineTool.Height > 1 then + LineTool.Height := LineTool.Height - 1; + LineTool.Top := LineToolPanel.Height div 2 - (LineTool.Height + 1) div 2; + if DrawingTool = dtPoint then + begin + Bmp.Canvas.Pen.Width := 1; + VisualBmp.Canvas.Pen.Width := 1; + end + else + begin + Bmp.Canvas.Pen.Width := LineTool.Height; + VisualBmp.Canvas.Pen.Width := LineTool.Height; + end; +end; + +procedure TMainForm.Pattern1Click(Sender: TObject); +begin + Pattern1.Checked := not Pattern1.Checked; + UpdateBmp (TRUE); +end; + + +procedure TMainForm.ImportTiles1Click(Sender: TObject); + var + BlockW, BlockH, + SkipX, SkipY, + SkipW, SkipH: Integer; + ai: array of Integer; + i: Integer; + Unique: Boolean; +begin + + if OpenPictureDialog.Execute then + begin + ImportTiles.Result := FALSE; + ImportTiles.ShowModal; + if ImportTiles.Result then + begin + with ImportTiles do + begin + BlockW := TileWidth.Value; + BlockH := TileHeight.Value; + SkipX := ClipLeft.Value; + SkipY := ClipTop.Value; + SkipW := HorzSpace.Value; + SkipH := VertSpace.Value; + Unique := RemoveDuplicates.Checked; + + if (BlockW >= 4) and (BlockH >= 4) and + (SkipX >= 0) and (SkipY >= 0) and + (SkipW >= 0) and (SkipH >= 0) then + begin + + CreateNewTileCollection (Identifier.Text, BlockW, BlockH, TRUE); + + SetLength (ai, Length (TransList)); + for i := 0 to Length (ai) - 1 do + ai[i] := TransList[i]; + (* + with TileTab[Tab.TabIndex] do + if tbr.TileBitmap <> nil then + tbr.TileBitmap.Free; + *) + FreeTBR (TileTab[Tab.TabIndex].tbr); + + MainForm.ProgressPanel.Visible := TRUE; + + TileTab[Tab.TabIndex].tbr := + ReadTileBitmap (OpenPictureDialog.Filename, + BlockW, BlockH, TransX, TransY, + ai, + SkipX, SkipY, + SkipW, SkipH, + ProgressBar, + FALSE, + Unique, + FALSE, + TileTab[Tab.TabIndex].tbr); + + TileTab[Tab.TabIndex].tbr.BackGr := BackGround.Brush.Color; + + SetLength (ai, 0); + + MainForm.ProgressPanel.Visible := FALSE; + end + else + ShowMessage ('Invalid parameters.'); + end; + + TabChange (Sender); + Modified := TRUE; + end; + end; + UpdateTileBitmap; +end; + +procedure TMainForm.DrawCursor; + var + L, C: Integer; + + procedure Rct (Canvas: TCanvas; X, Y, W, H: Integer); + begin + Canvas.Rectangle (X, Y, X + W, Y + H); + end; + +begin + C := CursorSize; + with TileTab[Tab.TabIndex] do + begin + with CursorImage do + begin + L := tbr.Current * W - TileScrollBox.HorzScrollBar.ScrollPos; + + while (L < 0) and (TileScrollBox.HorzScrollBar.Position >= W) do + begin + TileScrollBox.HorzScrollBar.Position := TileScrollBox.HorzScrollBar.Position - W; + L := tbr.Current * W - TileScrollBox.HorzScrollBar.ScrollPos; + end; + if L < 0 then + TileScrollBox.HorzScrollBar.Position := 0; + + while L > TileScrollBox.Width - W do + begin + TileScrollBox.HorzScrollBar.Position := TileScrollBox.HorzScrollBar.Position + W; + L := tbr.Current * W - TileScrollBox.HorzScrollBar.ScrollPos; + end; + Left := L; + Top := 0; + with Canvas do + begin + Pen.Color := clBlack; + Pen.Style := psSolid; + Brush.Color := clWhite; + Brush.Style := bsSolid; + end; + + Rct (Canvas, 0, 0, C, C); + Rct (Canvas, W div 2 - C div 2, 0, C, C); + Rct (Canvas, W - C, 0, C, C); + Rct (Canvas, 0, H div 2 - C div 2, C, C); + Rct (Canvas, W - C, H div 2 - C div 2, C, C); + Rct (Canvas, 0, H - C, C, C); + Rct (Canvas, W div 2 - C div 2, H - C, C, C); + Rct (Canvas, W - C, H - C, C, C); + end; + end; + + TileSelection.Visible := FALSE; + +end; + +procedure TMainForm.ShowStatusInfo; + var + b: Boolean; + OfsX, OfsY: Integer; +begin + if Tab.TabIndex > -1 then + with TileTab[Tab.TabIndex] do + begin + StatusBar.Panels[3].Text := Format ('Tile %d of %d', [tbr.Current + 1, tbr.TileCount]); + + with StatusBar.Panels[5] do // 2.4 + begin + with tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + begin + OfsX := tbr.OffsetX[tbr.Current]; + OfsY := tbr.OffsetY[tbr.Current]; + Text := Format ('(%d, %d)', [OfsX, OfsY]); + end + else + Text := ''; + if Text = '(0, 0)' then + Text := ''; + end; + end; + + if Mode = mTile then + begin + StatusBar.Panels[0].Text := Format ('Size: %d x %d', [W, H]); + + Copy1.Enabled := TRUE; + Cut1.Enabled := TRUE; + Delete1.Enabled := TRUE; + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + RandomFill1.Enabled := FALSE; + ClearArea1.Enabled := FALSE; + MapScrollFunction1.Enabled := FALSE; + ReplaceSelectedTile1.Enabled := FALSE; + + RemoveMap1.Enabled := FALSE; + MapProperties1.Enabled := FALSE; + end; + + Copy1.Caption := 'Copy'; + + if Mode = mMap then + begin + with TileTab[Tab.TabIndex].tbr.Maps do // 2.53 + begin + NextMap1.Enabled := Length (aMaps) > 0; + PreviousMap1.Enabled := Length (aMaps) > 0; + MoveMapLeft1.Enabled := (Length (aMaps) > 0) and // 2.55 + (CurMap > 0); + MoveMapRight1.Enabled := (Length (aMaps) > 0) and // 2.55 + (CurMap < Length (aMaps) - 1); + + ScaledPaste1.Enabled := FALSE; + end; + + if lmp <> nil then + StatusBar.Panels[0].Text := Format ('Size: %d x %d', [CurMapW, CurMapH]) + else + StatusBar.Panels[0].Text := ''; + + // StatusBar.Panels[1].Text := Format ('(%d, %d)', [i, j]); + // StatusBar.Panels[1].Text := Format ('(%d, %d)-', [i, j]) + + // StatusBar.Panels[1].Text; + + Copy1.Enabled := true; // { bug: } (ClipTab.TabIndex > -1); // Selection; // 2.54 copy current tile + if not Selection then Copy1.Caption := 'Copy Tile Combination'; + + Cut1.Enabled := Selection; + Delete1.Enabled := Selection or (ClipTab.TabIndex > -1); + + ConverttoTileSequence1.Enabled := Selection; + InsertTileSequence1.Enabled := Selection; + RemoveTileSequence1.Enabled := SeqTab.TabIndex > -1; + ReplaceCurrentTileSequence1.Enabled := Selection and (SeqTab.TabIndex > -1); + + b := Selection and (ClipTab.TabIndex > -1); + Paste1.Enabled := b; + StretchPaste1.Enabled := b; + RandomFill1.Enabled := b; + ClearArea1.Enabled := b; + ReplaceSelectedTile1.Enabled := b; + + RemoveMap1.Enabled := MapTab.TabIndex > -1; + MapProperties1.Enabled := MapTab.TabIndex > -1; + MapScrollFunction1.Enabled := MapTab.TabIndex > -1; + + end; + + UtilsTab.Visible := (Mode = mTile); + + b := (Mode = mMap) and (MapTab.TabIndex > -1); + InsertHorizontal1.Enabled := b; + InsertVertical1.Enabled := b; + DeleteHorizontal1.Enabled := b; + DeleteVertical1.Enabled := b; + ImportMap1.Enabled := b; + ExportMap1.Enabled := b; + + ShowMapLayer1.Enabled := b; // 2.54 + + ReplaceColorUnderCursor1.Enabled := (Mode = mTile); +end; + +procedure TMainForm.StartEdit (UpdateAll: Boolean); +begin + if Length (TileTab) > 0 then + with TileTab[Tab.TabIndex] do + begin + if tbr.TileCount = 0 then + begin + CreateNewTile (tbr); + UpdateTileBitmap; + end; + + if UpdateAll then + begin + // TileBitmap.Width := tbr.TileCount * tbr.W; + // TileBitmap.Height := tbr.H; + + // TileBitmap.Picture.Bitmap := tbr.TileBitmap; + + // TileScrollBox.HorzScrollBar.Range := TileBitmap.Width; + TileScrollBox.HorzScrollBar.Increment := tbr.W; + TilePanel.Height := + tbr.H + + 16 // (TileScrollBox.Height - TileScrollBox.ClientHeight) + + (Tab.TabHeight) + + StatusBar.Height + + 10; + end; + + if Mode = mTile then + begin + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + tbr.TileBitmap.Canvas, MakeRect (tbr.Current * W, 0, W, H)); + + Tile.Transparent := FALSE; + Tile.Stretch := TRUE; + Tile.Picture.Graphic := VisualBmp; + + Bounds := GetBound (tbr, -1); + end; + + TileMouseMove (nil, [], LastX, LastY); + + BoundBox.RePaint; + DrawCursor; + + if UpdateAll then + MainForm.Resize; + + if Mode = mTile then + begin + ClearUndo; + if not UpdateAll then + UpdateBmp (TRUE); + end + else + ShowStatusInfo; + end; +end; + + +procedure TMainForm.NewTile1Click(Sender: TObject); +begin + UpdateBmp (TRUE); + AllowMultEmptyTiles := Sender = NewTile1; + CreateNewTile (TileTab[Tab.TabIndex].tbr); + AllowMultEmptyTiles := FALSE; + UpdateTileBitmap; + StartEdit (TRUE); + + Modified := TRUE; +end; + +procedure TMainForm.TileBitmapMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + var i, j: Integer; +begin + if Button = mbRight then + begin + if OnionSkinTile = X div W then + OnionSkinTile := -1 + else + begin + OnionSkinTile := X div W; + with TileTab[Tab.TabIndex] do + OnionSkinBmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + tbr.TileBitmap.Canvas, MakeRect (OnionSkinTile * W, 0, W, H)); + end; + UpdateBMP (TRUE); + Exit; + end; + OnionSkinTile := -1; + + if Sender = TileBitmap then + TileTab[Tab.TabIndex].tbr.Current := X div W; + + if Mode = mMap then + if Button = mbLeft then + begin + SelectCurrentTile (TileTab[Tab.TabIndex].tbr.Current); + DrawCurrentTile; + end; + + StartEdit (TRUE); +end; + +function TMainForm.ColorMatch (C: Integer): Integer; + var + R, G, B: Integer; + rr, gg, bb: Integer; + i, j, k, l: Integer; +begin + GetRGB (C, R, G, B); + + if Pal256 and (CountEnabledColors > 0) then + begin + + k := -1; + l := -1; + for i := 0 to 255 do + if Enable256[i] then + begin + GetRGB (PaletteValues[i], rr, gg, bb); + j := sqr ((r - rr) * 2) + sqr ((g - gg) * 2) + sqr ((b - bb) * 2); + if (k = -1) or (j < l) then + begin + k := i; + l := j; + end; + end; + ColorMatch := PaletteValues[k]; + Exit; + + end + else + + if ShowCurrentPalette1.Checked then + with UsedColorsImage.Picture.Bitmap do + if Height > 1 then + begin + k := -1; + l := -1; + for i := 0 to Height - 1 do + begin + GetRGB (Canvas.Pixels[0, i], rr, gg, bb); + j := sqr ((r - rr) * 2) + sqr ((g - gg) * 2) + sqr ((b - bb) * 2); + if (k = -1) or (j < l) then + begin + k := i; + l := j; + end; + end; + ColorMatch := Canvas.Pixels[0, k]; + Exit; + end; + + i := 128 div (MaxRGB - 1); + j := 255 div (MaxRGB - 1); + + R := LimitRGB ((R + i) div j * j); + G := LimitRGB ((G + i) div j * j); + B := LimitRGB ((B + i) div j * j); + + Inc (R, R div 64); + Inc (G, G div 64); + Inc (B, B div 64); + + if R > 255 then R := 255; + if G > 255 then G := 255; + if B > 255 then B := 255; + + c := RGB (R, G, B); + if c = TRANS_COLOR then + c := TRANS_COLOR_REPLACEMENT; + + ColorMatch := c; +end; + +procedure TMainForm.MatchColors1Click(Sender: TObject); + var + i, j, k, x, y: Integer; +begin + GetTileArea; + SaveUndo ('Match Colors'); + for j := 0 to TileAreaH do + for i := 0 to TileAreaW do + begin + x := TileAreaX + i; + y := TileAreaY + j; + k := Bmp.Canvas.Pixels[x, y]; + if k <> TRANS_COLOR then + Bmp.Canvas.Pixels[x, y] := ColorMatch (k); + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.SwapWithUndo; + var + ur: UndoRec; +begin + ur.Bmp := TBitmap.Create; + SetStretchBltMode(ur.Bmp.Canvas.Handle, HALFTONE); + ur.Bmp.PixelFormat := pf24bit; + ur.Bmp.Width := W; + ur.Bmp.Height := H; + ur.Bmp.Canvas.CopyRect (Rect (0, 0, W, H), + Undo[UndoPos].Bmp.Canvas, Rect (0, 0, W, H)); + ur.ActionName := Undo[UndoPos].ActionName; + + Undo[UndoPos].Bmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + Undo[UndoPos].ActionName := Action; + + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + ur.Bmp.Canvas, Rect (0, 0, W, H)); + Action := ur.ActionName; + ur.Bmp.Free; + Modified := TRUE; +end; + +procedure TMainForm.Undo1Click(Sender: TObject); +begin +// UndoButton.Down := FALSE; + if not Undo1.Enabled then + Exit; + + if Undo[UndoPos].HistoryCoords <> '' then + HistoryListBox.Items.Delete(HistoryListBox.Items.Count - 1); + + SwapWithUndo; + + if UndoPos = 0 then + begin + Undo1.Caption := '&Undo'; + Undo1.Enabled := FALSE; + { + UndoButton.Down := FALSE; + UndoButton.Enabled := FALSE; + } + end + else + Undo1.Caption := '&Undo ' + Undo[UndoPos - 1].ActionName; + + Redo1.Caption := '&Redo ' + Action; + Redo1.Enabled := TRUE; +{ + RedoButton.Enabled := TRUE; +} + Dec (UndoPos); + + UpdateBmp (TRUE); +end; + +procedure TMainForm.Redo1Click(Sender: TObject); +begin +// RedoButton.Down := FALSE; + if not Redo1.Enabled then + Exit; + + Inc (UndoPos); + + SwapWithUndo; + + if Undo[UndoPos].HistoryCoords <> '' then + HistoryListBox.Items.Add(Undo[UndoPos].HistoryCoords); + + if UndoPos = UndoCount - 1 then + begin + Redo1.Caption := '&Redo'; + Redo1.Enabled := FALSE; + { + RedoButton.Down := FALSE; + RedoButton.Enabled := FALSE; + } + end + else + Redo1.Caption := '&Redo ' + Action; + + Undo1.Caption := '&Undo ' + Undo[UndoPos].ActionName; + Undo1.Enabled := TRUE; +{ + UndoButton.Enabled := TRUE; +} + UpdateBmp (TRUE); +end; + +procedure TMainForm.SaveTempBmp; +begin + TempBmp.Canvas.CopyRect (Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H), + Bmp.Canvas, Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H)); +end; + +procedure TMainForm.Copy1Click(Sender: TObject); + var + n, i, j: Integer; +begin + if Mode = mTile then + begin + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + i := TileSelX2 - TileSelX1; + j := TileSelY2 - TileSelY1; + ClipBmp.Width := i; + ClipBmp.Height := j; + ClipBmp.Canvas.CopyRect (Rect (0, 0, i, j), + Bmp.Canvas, MakeRect (TileSelX1, TileSelY1, i, j)); + ClipBoard.Assign (ClipBmp); + TileSelection.Visible := FALSE; + end + else + begin + ClipBmp.Width := W; + ClipBmp.Height := H; + ClipBmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + ClipBoard.Assign (ClipBmp); + end; + ScaledPaste1.Enabled := TRUE; + end; + if Mode = mMap then + begin + if not Selection then + begin + ClipBmp.Width := W; + ClipBmp.Height := H; + ClipBmp.Canvas.CopyRect (Rect (0, 0, W, H), + bmpPreview.Canvas, MakeRect (0, 0, W, H)); + ClipBoard.Assign (ClipBmp); // 2.54 + Exit; + end; + + with Area do + begin + ClipW := Right - Left + 1; + ClipH := Bottom - Top + 1; + NewClipMap (TileTab[Tab.TabIndex].tbr, ClipW, ClipH); + end; + n := ClipTab.Tabs.Count; + + ClipTab.TabIndex := ClipTab.Tabs.Add (IntToStr (n)); + + clip := SelectClipMap (TileTab[Tab.TabIndex].tbr, n); + with Area do + for j := Top to Bottom do + for i := Left to Right do + clip^.Map[j - Top, i - Left] := lmp^.Map[j, i]; + + ClipTabChange (Sender); + + Selection := FALSE; + UpdateMapRegion(Area); + + end; + Paste1.Enabled := TRUE; + StretchPaste1.Enabled := TRUE; +end; + + +procedure TMainForm.Paste1Click(Sender: TObject); + var + i, j, k: Integer; + x, y: Integer; + X1, Y1, X2, Y2: Integer; +begin + if Mode = mTile then + if Clipboard.HasFormat(CF_BITMAP) then + begin + SaveUndo ('Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + + with ClipBmp do + begin + X1 := 0; + Y1 := 0; + X2 := W; + Y2 := H; + + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + X1 := TileSelX1 - BORDER_W; + Y1 := TileSelY1 - BORDER_H; + X2 := TileSelX2 - BORDER_W - 1; + Y2 := TileSelY2 - BORDER_H - 1; + end; + + // Bmp.Canvas.Draw(BORDER_W, BORDER_H, ClipBmp); + for j := Y1 to Y2 do + for i := X1 to X2 do + begin + x := i - X1; + y := j - Y1; + if (x < ClipBmp.Width) and (y < ClipBmp.Height) then + begin + k := ClipBmp.Canvas.Pixels[x, y]; + if k <> TRANS_COLOR then + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := k; + end; + end; + end; + TileSelection.Visible := FALSE; + UpdateBmp (TRUE); + end; + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + y := (j - Top) mod ClipH; + x := (i - Left) mod ClipW; + lmp^.Map[j, i] := clip^.Map[y, x]; + end; + Selection := FALSE; + UpdateMapRegion(Area); + end; + Modified := TRUE; +end; + +procedure TMainForm.Delete1Click(Sender: TObject); + var + i, j: Integer; +begin + if Mode = mTile then + begin + if TileSelection.Visible then + begin + SaveUndo ('Clear'); + + for j := TileSelY1 to TileSelY2 - 1 do + for i := TileSelX1 to TileSelX2 - 1 do + Bmp.Canvas.Pixels[i, j] := TRANS_COLOR; + + TileSelection.Visible := FALSE; + UpdateBmp (TRUE); + Modified := TRUE; + end + else + begin + + ClearUndo; // bugfix + + UpdateBmp (TRUE); + // Clear1Click (Sender); + with TileTab[Tab.TabIndex] do + begin + i := CountTileUsed (tbr); + if i > 0 then + if MessageDlg ('Tile is used ' + IntToStr (i) + + ' time(s). Remove anyway?', mtWarning, + [mbOk, mbCancel], 0) = mrCancel then + Exit; + RemoveTile (tbr); + if tbr.TileCount = 0 then + CreateNewTile (tbr); + UpdateTileBitmap; + end; + Modified := TRUE; + StartEdit (TRUE); + end; + end; + + if Mode = mMap then + begin + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + ClearMCR (lmp^.Map[j, i]); + Modified := TRUE; + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end + else + if ClipTab.TabIndex > -1 then + begin + RemoveClip (TileTab[Tab.TabIndex].tbr, ClipTab.TabIndex); + with ClipTab do + begin + j := TabIndex; + Tabs.Delete (TabIndex); + for i := j to Tabs.Count - 1 do + Tabs.Strings[i] := IntToStr (StrToInt (Tabs.Strings[i]) - 1); + + if j <= Tabs.Count - 1 then + TabIndex := j + else + TabIndex := Tabs.Count - 1; + end; + ClipTabChange (Sender); + Modified := TRUE; + end + else + SelectCurrentTile (-1); + + Delete1.Enabled := Selection or (ClipTab.TabIndex > -1); + end; + +end; + +procedure TMainForm.Cut1Click(Sender: TObject); + var + Sel, TSel: Boolean; +begin + Sel := Selection; + TSel := TileSelection.Visible; + Copy1Click (Sender); + if Sel then + Selection := TRUE; + if TSel then + TileSelection.Visible := TRUE; + Delete1Click (Sender); +end; + +procedure TMainForm.MoveTileLeftClick(Sender: TObject); +begin + UpdateBmp (TRUE); + if MoveLeft (TileTab[Tab.TabIndex].tbr, TRUE) then + begin + // TileBitmap.Picture.Bitmap := TileTab[tab.TabIndex].tbr.TileBitmap; + UpdateTileBitmap; + DrawCursor; + Modified := TRUE; + end; + // StartEdit; + ShowStatusInfo; +end; + +procedure TMainForm.MoveTileRightClick(Sender: TObject); +begin + UpdateBmp (TRUE); + if MoveRight (TileTab[Tab.TabIndex].tbr, TRUE) then + begin + // TileBitmap.Picture.Bitmap := TileTab[tab.TabIndex].tbr.TileBitmap; + UpdateTileBitmap; + DrawCursor; + Modified := TRUE; + end; + // StartEdit; + ShowStatusInfo; +end; + +procedure TMainForm.RemoveDuplicateTiles1Click(Sender: TObject); +begin + ProgressPanel.Visible := TRUE; + Tiles.RemoveDuplicates (TileTab[Tab.TabIndex].tbr, ProgressBar); + StartEdit (TRUE); + ProgressPanel.Visible := FALSE; + UpdateTileBitmap; + Modified := TRUE; +end; + +procedure TMainForm.ShowRGB (color: Integer); + const + LastColor: Integer = -1; + var + R, G, B: Integer; + cR, cG, cB: Char; +begin + ColorUnderMousePointer := color; // 3.0 + cR := 'r'; cG := 'g'; cB := 'b'; + if color <> LastColor then + begin + GetRGB (color, R, G, B); + if color <> ColorMatch (color) then + begin cR := 'R'; cG := 'G'; cB := 'B'; end; + if color = TRANS_COLOR then + StatusBar.Panels[2].Text := 'Transparent' + else + StatusBar.Panels[2].Text := Format ('%s: %d, %s: %d, %s: %d', + [cR, R, cG, G, cB, B]); + LastColor := color; + end; +end; + +procedure TMainForm.ColorMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); +begin + ShowRGB (Color.Brush.Color); +end; + +procedure TMainForm.BackGroundMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); +begin + ShowRGB (TRANS_COLOR); +end; + +procedure TMainForm.About1Click(Sender: TObject); +begin + AboutForm.WebSite.Caption := URL; + AboutForm.ShowModal; +end; + +procedure TMainForm.Homepage1Click(Sender: TObject); + var + Param: string; +begin + Param := URL; + ShellExecute (0, 'open', PChar (Param), Nil, Nil, SW_SHOWNORMAL); +end; + +procedure TMainForm.ExportTiles1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + begin + if tbr.TileCount = 0 then + Exit; + + ExportTiles.ShowModal; + + with ExportTiles do + if Result then + begin + SavePictureDialog.DefaultExt := GraphicExtension(TBitmap); + SavePictureDialog.FileName := tbr.Filename; + if SavePictureDialog.Execute then + begin + ProgressPanel.Visible := TRUE; + WriteTileBitmap (SavePictureDialog.FileName, + MaxWidth.Value, + TransColor.Brush.Color, + BorderColor.Brush.Color, + Between.Value, Between.Value, + Edge.Value, Edge.Value, + tbr, + ProgressBar, + TransBottomRight.Checked, + FALSE, + SavePictureDialog.FilterIndex); + ProgressPanel.Visible := FALSE; + end; + end; + + end; +end; + +procedure TMainForm.DrawBounds (c: TCanvas; X, Y, Wid, Ht, lw, Bounds, Color: Integer); + var + X1, Y1, X2, Y2: Integer; + W, H, HW, HH: Integer; + MirV: Integer; +begin + with c do + begin + Pen.Style := psSolid; + Pen.Color := Color; + Pen.Width := lw; + + X1 := X + 1 + lw div 2; + Y1 := Y + 1 + lw div 2; + X2 := X + Wid - 1 - X1 - Byte (lw = 1); + Y2 := Y + Ht - 1 - Y1 - Byte (lw = 1); + W := X2 - X1; + H := Y2 - Y1; + HW := W div 2; + HH := H div 2; + + if Bounds <> 0 then + // if Bounds and $70 = 0 then + if ShortInt (Bounds) > 0 then + begin + { horizontal and vertical } + + if (Bounds and $1 = 1) then + begin + MoveTo (X1, Y1); + LineTo (X2, Y1); + Pixels[X2, Y1] := Color; + end; + if (Bounds and $2 = 2) then + begin + MoveTo (X1, Y1); + LineTo (X1, Y2); + Pixels[X1, Y2] := Color; + end; + if (Bounds and $4 = 4) then + begin + MoveTo (X1, Y2); + LineTo (X2, Y2); + Pixels[X2, Y2] := Color; + end; + if (Bounds and $8 = 8) then + begin + MoveTo (X2, Y1); + LineTo (X2, Y2); + Pixels[X2, Y2] := Color; + end; + + end + else + begin + { diagonal } + + MirV := 0; + if Bounds and $1 = $1 then + MirV := X2 - X1; + + case (Bounds and $3F) shr 1 of + 0: begin MoveTo (X2 - MirV, Y1); LineTo (X1 + MirV, Y2); end; + 1: begin MoveTo (X1 + HW, Y1); LineTo (X1 + MirV, Y2); end; + 2: begin MoveTo (X2 - MirV, Y1); LineTo (X2 - HW, Y2); end; + 3: begin MoveTo (X1 + MirV, Y2); LineTo (X2 - MirV, Y2 - HH); end; + 4: begin MoveTo (X1 + MirV, Y1 + HH); LineTo (X2 - MirV, Y1); end; + + end; + + end; + + end; +end; + +procedure TMainForm.BoundBoxPaint(Sender: TObject); + const + LastBounds: Integer = 0; + var + i, j, b: Integer; +begin + if Tab.TabIndex = -1 then + Exit; + + if Bounds = LastBounds then + if (Mode = mMap) and Selection then + Exit; // quick fix for strange bug: select area in map, set diagonal bound, keeps refreshing + + with BoundBox.Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := clBtnFace; + Pen.Style := psClear; + FillRect (Rect (0, 0, Width, Height)); + end; + DrawBounds (BoundBox.Canvas, 0, 0, BoundBox.Width, BoundBox.Height, 3, Bounds, clBlack); + + if Mode = mTile then + with BoundBox.Canvas do + begin + Pen.Style := psSolid; + Pen.Width := 1; + Pen.Color := clGray; + Brush.Style := bsClear; + i := BoundBox.Width div 2; + i := i + XShade * i div 3; + j := BoundBox.Height div 2; + j := j + YShade * j div 3; + Ellipse (i - 5, j - 5, i + 5, j + 5); + end; + + if Mode = mTile then + SetBound (TileTab[Tab.TabIndex].tbr, Bounds) + else + if TileTab[Tab.TabIndex].tbr.mcr.Bounds and (not $40) <> Bounds and (not $40) then + begin + TileTab[Tab.TabIndex].tbr.mcr.Bounds := + ShortInt ((TileTab[Tab.TabIndex].tbr.mcr.Bounds and $40) or (Bounds and (not $40))); + ShowSelectedTile; + end; + + if (Mode = mMap) and Selection then + if Bounds <> LastBounds then + begin + // if Bounds < $10 then + // if Bounds and $70 = 0 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + b := lmp^.Map[j, i].Bounds and (not $40); + if b > $F then + b := 0; + if (Bounds and 1) <> (LastBounds and 1) then + b := (b and (not 1)) or ((Bounds and 1) * (Byte (j = Area.Top))); + if (Bounds and 2) <> (LastBounds and 2) then + b := (b and (not 2)) or ((Bounds and 2) * (Byte (i = Area.Left))); + if (Bounds and 4) <> (LastBounds and 4) then + b := (b and (not 4)) or ((Bounds and 4) * (Byte (j = Area.Bottom))); + if (Bounds and 8) <> (LastBounds and 8) then + b := (b and (not 8)) or ((Bounds and 8) * (Byte (i = Area.Right))); + lmp^.Map[j, i].Bounds := (lmp^.Map[j, i].Bounds and $40) or ShortInt (b); + end; + // Selection := FALSE; + + UpdateMapRegion(Area); + Modified := TRUE; + + end + else + begin + + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + b := lmp^.Map[j, i].Bounds and (not $40); + if ((Bounds = $81) and (i - Area.Left = j - Area.Top)) or + ((Bounds = $80) and (Area.Right - i = j - Area.Top)) then + b := Bounds; +{ + b := lmp^.Map[j, i].Bounds; + if (Bounds and 1) <> (LastBounds and 1) then + b := (b and (not 1)) or ((Bounds and 1) * (Byte (j = Area.Top))); + if (Bounds and 2) <> (LastBounds and 2) then + b := (b and (not 2)) or ((Bounds and 2) * (Byte (i = Area.Left))); + if (Bounds and 4) <> (LastBounds and 4) then + b := (b and (not 4)) or ((Bounds and 4) * (Byte (j = Area.Bottom))); + if (Bounds and 8) <> (LastBounds and 8) then + b := (b and (not 8)) or ((Bounds and 8) * (Byte (i = Area.Right))); +} + lmp^.Map[j, i].Bounds := (lmp^.Map[j, i].Bounds and $40) or ShortInt (b); + end; + // Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + + end; + end; + + LastBounds := Bounds; +end; + +procedure TMainForm.Top1Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $1 + else + Bounds := $1; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.Bottom1Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $4 + else + Bounds := $4; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.Left2Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $2 + else + Bounds := $2; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.Right2Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $8 + else + Bounds := $8; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.DiagonalUp1Click(Sender: TObject); +begin + if Bounds = $80 then + Bounds := $00 + else + Bounds := $80; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.DiagonalDown1Click(Sender: TObject); +begin + if Bounds = $81 then + Bounds := $00 + else + Bounds := $81; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.ClearAll1Click(Sender: TObject); +begin + Bounds := 0; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.BoundBoxMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + var + xx, yy: Boolean; +begin + Dec (X, BoundBox.Width div 2); + Dec (Y, BoundBox.Height div 2); + xx := Abs (X) >= BoundBox.Width div 4; + yy := Abs (Y) >= BoundBox.Height div 4; + + if (ssShift in Shift) then + begin + XShade := X div (BoundBox.Width div 5); + YShade := Y div (BoundBox.Height div 5); + BoundBox.Repaint; + end + else + begin + if xx and yy then + if X * Y < 0 then + DiagonalUp1Click (Sender) + else + DiagonalDown1Click (Sender) + else if xx then + begin + if X > 0 then + Right2Click (Sender) + else + Left2Click (Sender); + end + else if yy then + begin + if Y > 0 then + Bottom1Click (Sender) + else + Top1Click (Sender); + end + else + ClearAll1Click (Sender); + end; +end; + +procedure TMainForm.NewTileCollection1Click(Sender: TObject); +begin + with NewForm do + begin + NewMode := nmNewTileSet; + DefaultName := NewTCName; + CanChangeSize := TRUE; + DefaultOverlap := 0; + ShowModal; + if Result then + begin + if TileWidth.Value < 1 then TileWidth.Value := 1; // 2.4 + if TileHeight.Value < 1 then TileHeight.Value := 1; + + CreateNewTileCollection (Identifier.Text, TileWidth.Value, TileHeight.Value, TRUE); + TabChange (Sender); + TileTab[Tab.TabIndex].tbr.Overlap := Overlap.Value; + TileTab[Tab.TabIndex].tbr.SkipExport := Skip.Checked; // 2.2 + Modified := TRUE; + end; + end; +end; + +procedure TMainForm.CreateNewTileCollection (Name: string; BW, BH: Integer; AddNew: Boolean); + var + cr: Integer; +begin + if AddNew then + begin + cr := Length (TileTab); + SetLength (TileTab, cr + 1); + Tab.Tabs.Add (Name); + Tab.TabIndex := cr; + end; + + SetTileSize (BW, BH); + + TileTab[Tab.TabIndex].id := Name; + + Scale := DEFAULT_SCALE - BW div 8 + 4 - BH div 8 + 4; + if Scale < 1 then Scale := 1; + while (Scale * (BW + 2 * BORDER_W) < ScrollBox.ClientWidth) and + (Scale * (BH + 2 * BORDER_H) < ScrollBox.ClientHeight - 2 * BH) do + Inc (Scale); + + if Scale > MAX_SCALE then Scale := MAX_SCALE; + with TileTab[Tab.TabIndex] do + begin + lastscale := Scale; + lastscrollpos := 0; + AnimStart := -1; + AnimEnd := -1; + BackGrColor := Background.Brush.Color; + end; + + TileTab[Tab.TabIndex].tbr := CreateNewTBR (BW, BH); + + CreateNewTile (TileTab[Tab.TabIndex].tbr); + UpdateTileBitmap; + + DrawCursor; +end; + +function TMainForm.NewTCName: string; + var + Name: string; + i: Integer; +begin + i := 0; + repeat + Inc (i); + Name := 'Tiles' + IntToStr (i); + until Tab.Tabs.IndexOf (Name) = -1; + NewTCName := Name; +end; + +function TMainForm.NewMapName: string; + var + Name: string; + i: Integer; +begin + i := 0; + repeat + Inc (i); + Name := 'Map' + IntToStr (i); + until MapTab.Tabs.IndexOf (Name) = -1; + NewMapName := Name; +end; + +procedure TMainForm.Properties1Click(Sender: TObject); + var + OldW, OldH, NewW, NewH: Integer; +begin + with NewForm do + begin + NewMode := nmTileSetProperties; + DefaultName := TileTab[Tab.TabIndex].id; + CanChangeSize := HasNoTiles (TileTab[Tab.TabIndex].tbr); + OldW := TileTab[Tab.TabIndex].tbr.W; + OldH := TileTab[Tab.TabIndex].tbr.H; + TileWidth.Value := OldW; + TileHeight.Value := OldH; + + Skip.Checked := TileTab[Tab.TabIndex].tbr.SkipExport; // 2.2 + + DefaultOverlap := TileTab[Tab.TabIndex].tbr.Overlap; + ShowModal; + if Result then + with TileTab[Tab.TabIndex] do + begin + id := Identifier.Text; + Tab.Tabs.Strings[Tab.TabIndex] := Identifier.Text; + tbr.Overlap := Overlap.Value; + + if TileWidth.Value < 1 then TileWidth.Value := 1; // 2.4 + if TileHeight.Value < 1 then TileHeight.Value := 1; + + NewW := TileWidth.Value; + NewH := TileHeight.Value; + + tbr.SkipExport := Skip.Checked; // 2.2 + + if (NewW <> OldW) or (NewH <> OldH) then + begin + CreateNewTileCollection (Identifier.Text, NewW, NewH, FALSE); + + MainForm.Resize; + StartEdit (TRUE); + end; + SetEditorMode (mTile); + Modified := TRUE; + end; + end; +end; + +function TMainForm.TCNameOK (s: string; MayExist: Boolean): Boolean; + var + i: Integer; +begin + if Tab.Tabs.IndexOf (s) <> -1 then + TCNameOK := MayExist and (Tab.Tabs.IndexOf (s) = Tab.TabIndex) + else + begin + TCNameOK := FALSE; + if s = '' then + Exit; + if not (UpCase (s[1]) in ['A'..'Z']) then + Exit; + for i := 1 to Length (s) do + if not (UpCase (s[i]) in ['A'..'Z', '0'..'9', '_']) then + Exit; + TCNameOK := TRUE; + end; +end; + +procedure TMainForm.IdError (id: string); +begin + if id = '' then + MessageDlg ('An identifier is required.', mtError, [mbOk], 0) + else + if TCNameOk (id, TRUE) and (Tab.Tabs.IndexOf (id) <> Tab.TabIndex) then // 2.33 and ipv or + MessageDlg ('The name already exists.', mtError, [mbOk], 0) + else + MessageDlg ('The identifier "' + id + '" contains invalid characters.', mtError, [mbOk], 0); +end; + +procedure TMainForm.TabChange(Sender: TObject); + var + Cur: Integer; +begin +// UpdateBmp (TRUE); + +// if Mode <> mTile then +// SetEditorMode (mTile); + + with TileTab[Tab.TabIndex] do + begin + Cur := tbr.Current; + Background.Brush.Color := BackGrColor; + TileScrollBox.HorzScrollBar.Position := lastscrollpos; + Scale := lastscale; + tbr.Current := tbr.TileCount; // avoid clearing current tile + + SetTileSize (tbr.W, tbr.H); + + tbr.Current := Cur; + end; + + UpdateTileBitmap; + + + // MainForm.ScrollBox.SetFocus; + if Mode = mMap then + begin + MapDisplay.Visible := FALSE; + SetEditorMode (mMap); + end; + + StartEdit (TRUE); + HideUsedColors; +end; + +procedure TMainForm.Toolbar1Click(Sender: TObject); +begin + + Toolbar1.Checked := not Toolbar1.Checked; + ToolBar.Visible := Toolbar1.Checked; + MainForm.Resize; +end; + +procedure TMainForm.ActualSize1Click(Sender: TObject); +begin + if Mode = mTile then + begin + Scale := 1; + MainForm.Resize; + end; + if Mode = mMap then + begin + Zoom := ZOOM_FACTOR; + ZoomMap; + UpdateMap; + end; +end; + +procedure TMainForm.FitinWindow1Click(Sender: TObject); + var + WinW, WinH, iw, ih: Integer; +begin + WinW := ScrollBox.Width - 4; + WinH := ScrollBox.Height - 4; + iw := W + 2 * BORDER_W; + ih := H + 2 * BORDER_H; + Scale := 2; + while (iw * Scale < WinW) and (ih * Scale < WinH) + and (Scale <= MAX_SCALE) do + Inc (Scale); + Dec (Scale); + MainForm.Resize; +end; + +procedure TMainForm.SetPaletteDepth(Sender: TObject); +begin + if Sender = N61 then MaxRGB := 6 else + if Sender = N71 then MaxRGB := 7 else + if Sender = N81 then MaxRGB := 8 else + if Sender = N91 then MaxRGB := 9 else + MaxRGB := 10; + N61.Checked := MaxRGB = 6; + N71.Checked := MaxRGB = 7; + N81.Checked := MaxRGB = 8; + N91.Checked := MaxRGB = 9; + N101.Checked := MaxRGB = 10; + MaxR := MaxRGB; MaxG := MaxRGB; MaxB := MaxRGB; + if SmoothPalette1.Checked then + SmoothPalette1Click (Sender) + else + Palette.Repaint; +end; + +procedure TMainForm.DuplicateTile1Click(Sender: TObject); + var + TempBmp: TBitmap; + bnd: Integer; +begin + bnd := Bounds; + UpdateBmp (TRUE); + TempBmp := TBitmap.Create; + TempBmp.PixelFormat := pf24bit; + SetStretchBltMode(TempBmp.Canvas.Handle, HALFTONE); + with TempBmp do + begin + Width := W; + Height := H; + Canvas.CopyRect (Rect (0, 0, W, H), Bmp.Canvas, + MakeRect (BORDER_W, BORDER_H, W, H)); + end; + CreateNewTile (TileTab[Tab.TabIndex].tbr); + UpdateTileBitmap; +// StartEdit; + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + TempBmp.Canvas, Rect (0, 0, W, H)); + Bounds := bnd; + BoundBox.RePaint; + UpdateBmp (TRUE); + DrawCursor; + TempBmp.Free; + Modified := TRUE; +end; + +procedure TMainForm.SetBrightness(Sender: TObject); + var + N: Integer; +begin + if Sender = N_1 then N := 0 else + if Sender = N_2 then N := 1 else + if Sender = N_3 then N := 2 else + if Sender = N_4 then N := 3 else + if Sender = N_5 then N := 4 else + if Sender = N_6 then N := 5 else + if Sender = N_7 then N := 6 else + if Sender = N_8 then N := 7 else + N := 8; + FromToFirst := N; + FromToLast := N; + SetColor (FromToList[N], FALSE, FALSE); + FromTo.Repaint; +end; + +procedure TMainForm.PaletteDblClick(Sender: TObject); +begin +{ IgnorePaletteMouseDown := TRUE; + ColorDialog.Color := Color.Brush.Color; + if ColorDialog.Execute then + begin + ColorSelect := FALSE; + SetColor (ColorDialog.Color, FALSE, FALSE); + end; + ShowRGB (ColorDialog.Color); +} +end; + +procedure TMainForm.SetEditorMode (NewMode: TEditorMode); + var + TW, TH: Integer; + const + SPC_W = 3; + SPC_H = 3; + + procedure Arrange (var p: TPanel; + var bmp: TImage; + var spm: TSpeedButton; + var spu: TSpeedButton; + var spr: TSpeedButton; // 2.5 + n: Integer); + begin + with p do + begin + Left := 4 + n * (TW + 2); + Width := TW; + Height := TH; + end; + spu.Top := p.Top + p.Height + SPC_H + 2; + spm.Top := spu.Top; + spr.Top := spu.Top; + spu.Left := p.Left + p.Width div 3; + spm.Left := spu.Left - spm.Width; + spr.Left := spu.Left + spm.Width; + + with bmp do + begin + Left := SPC_W + BMFCenterAdd; + Top := SPC_H; + Width := W; + Height := H; + end; + ResizeBitmap (bmp); + FillBitmap (bmp, TRANS_COLOR); + bmp.Picture.Bitmap.TransparentColor := TRANS_COLOR; + end; + + var + i: Integer; + +begin { SetEditorMode - switch Tile/Map mode } + Mode := NewMode; + + ShowUsedColors1.Enabled := Mode = mTile; + ShowCurrentPalette1.Enabled := Mode = mTile; + + ShowUsedColorPatterns1.Enabled := Mode = mTile; + + TileSelection.Visible := FALSE; + + ShiftState := []; + + for i := 0 to StatusBar.Panels.Count - 1 do + StatusBar.Panels[i].Text := ''; + + if Mode = mMap then + begin + AnimationTimer.Enabled := False; + + MapTab.Tabs.Clear; + ClipTab.Tabs.Clear; + SeqTab.Tabs.Clear; + + + with TileTab[Tab.TabIndex] do + begin + for i := 0 to Length (tbr.Maps.aMaps) - 1 do + MapTab.Tabs.Add (tbr.Maps.aMaps[i].id); + MapTab.TabIndex := tbr.Maps.CurMap; + + for i := 0 to Length (tbr.Clip.aMaps) - 1 do + ClipTab.Tabs.Add (IntToStr (i)); + ClipTab.TabIndex := tbr.Clip.CurMap; + + for i := 0 to Length (tbr.Seq.aMaps) - 1 do + SeqTab.Tabs.Add (IntToStr (i)); + SeqTab.TabIndex := tbr.Seq.CurMap; + + Selection := FALSE; + Area := Rect (0, 0, 0, 0); + end; + + ScrollBox.Align := alNone; + ScrollBox.Visible := FALSE; + + ToolPanel.Visible := FALSE; + + UsedColors.Visible := FALSE; + PatternPanel.Visible := FALSE; + ColorsPanel.Visible := FALSE; + PalettePanel.Visible := FALSE; + + + CurTilePanel.Visible := TRUE; + TilePartsPanel.Visible := TRUE; + + TH := H + 2 * SPC_H; + TW := (RightPanelWidth - 12) div 3; + if TW < (W + 2 * SPC_W) then + TW := (W + 2 * SPC_W); + BMFCenterAdd := (TW - (W + 2 * SPC_W)) div 2; + + RightPanel.Width := 3 * TW + 12; + CurTilePanel.Height := TH + H + 10; + TilePartsPanel.Height := TH + 8 + bMir.Height + 2 * SPC_H; + + Arrange (pBack, bmpBack, bMir, bUps, bRot, 0); + Arrange (pMid, bmpMid, mMir, mUps, mRot, 1); + Arrange (pFront, bmpFront, fMir, fUps, fRot, 2); + + pPreview.Width := W + 2 * SPC_W; + pPreview.Height := H + 2 * SPC_H; + ResizeBitmap (bmpPreview); + bmpPreview.Left := SPC_W; + bmpPreview.Top := SPC_H; + bmpPreview.Width := 2 * W; + bmpPreview.Height := 2 * H; + bmpPreview.Stretch := TRUE; + pPreview.Width := 2 * W + 2 * SPC_W; + pPreview.Height := 2 * H + 2 * SPC_H; + pPreview.Top := 6; + pPreview.Left := CurTilePanel.Width div 2 - pPreview.Width div 2; + + ShowSelectedTile; + + MapToolPanel.Visible := TRUE; + ExtraPanel.Align := alBottom; + ExtraPanel.Height := 100; + ExtraPanel.Align := alTop; + + SeqTab.Align := alBottom; + SeqTab.Visible := TRUE; + SeqTab.Height := H + 2 * SPC_H + 32; + + ClipTab.Align := alClient; + ClipTab.Visible := TRUE; + + MapTab.Align := alClient; + MapTab.Visible := TRUE; + + Bounds := TileTab[Tab.TabIndex].tbr.mcr.Bounds; + BoundBox.Hint := 'Bounds'; + + SelectCurrentTile (TileTab[Tab.TabIndex].tbr.Current); + DrawCurrentTile; + end + else + if Mode = mTile then + begin + SeqTimer.Enabled := FALSE; + + + ClipTab.Align := alNone; + ClipTab.Visible := FALSE; + SeqTab.Align := alNone; + SeqTab.Visible := FALSE; + MapTab.Align := alNone; + MapTab.Visible := FALSE; + + + TilePartsPanel.Visible := FALSE; + CurTilePanel.Visible := FALSE; + + + RightPanel.Width := RightPanelWidth; + PalettePanel.Visible := TRUE; + ColorsPanel.Visible := TRUE; + PatternPanel.Visible := TRUE; + + ToolPanel.Visible := TRUE; + + ScrollBox.Align := alClient; + ScrollBox.Visible := TRUE; + + ExtraPanel.Height := 65; + MapToolPanel.Visible := FALSE; + + UsedColors.Visible := ShowUsedColors1.Checked or + ShowCurrentPalette1.Checked; + ColorPatternsPanel.Visible := ShowUsedColorPatterns1.Checked; + + if Length (TileTab) > 0 then + Bounds := GetBound (TileTab[Tab.TabIndex].tbr, -1) + else + Bounds := 0; + BoundBox.Hint := 'Default Bounds'; + end; + + Up1.Enabled := Mode = mTile; // 2.53 + Down1.Enabled := Mode = mTile; + Left1.Enabled := Mode = mTile; + Right1.Enabled := Mode = mTile; + + SelectNextClip1.Enabled := Mode = mMap; + SelectPreviousClip1.Enabled := Mode = mMap; + + FirstFrame1.Enabled := Mode = mTile; + LastFrame1.Enabled := Mode = mTile; + NextFrame1.Enabled := Mode = mTile; + PreviousFrame1.Enabled := Mode = mTile; + Animate1.Enabled := Mode = mTile; + Faster1.Enabled := Mode = mTile; + Default1.Enabled := Mode = mTile; + Slower1.Enabled := Mode = mTile; + + Pattern1.Enabled := Mode = mTile; + FitInWindow1.Enabled := Mode = mTile; + + RemoveTileSet1.Enabled := Mode = mTile; + + SaveCurrentTile1.Enabled := Mode = mTile; + ExportMapAsImage1.Enabled := Mode = mMap; + + SetGridGuidelines1.Enabled := Mode = mMap; + + NewTile1.Enabled := Mode = mTile; + Clear1.Enabled := Mode = mTile; + MatchColors1.Enabled := Mode = mTile; + ReplaceColors1.Enabled := Mode = mTile; + SplitColorPattern1.Enabled := Mode = mTile; + Move1.Enabled := Mode = mTile; + DuplicateTile1.Enabled := Mode = mTile; + Flip1.Enabled := Mode = mTile; + + ToggleMultiple1.Enabled := Mode = mTile; + N_1.Enabled := Mode = mTile; + N_2.Enabled := Mode = mTile; + N_3.Enabled := Mode = mTile; + N_4.Enabled := Mode = mTile; + N_5.Enabled := Mode = mTile; + N_6.Enabled := Mode = mTile; + N_7.Enabled := Mode = mTile; + N_8.Enabled := Mode = mTile; + N_9.Enabled := Mode = mTile; + RearrangePalette1.Enabled := Mode = mTile; + N61.Enabled := Mode = mTile; + N71.Enabled := Mode = mTile; + N81.Enabled := Mode = mTile; + N91.Enabled := Mode = mTile; + N101.Enabled := Mode = mTile; + + ConverttoTileSequence1.Enabled := FALSE; + InsertTileSequence1.Enabled := FALSE; + RemoveTileSequence1.Enabled := FALSE; + ReplaceCurrentTileSequence1.Enabled := FALSE; + + FlipCurrentTile1.Enabled := Mode = mMap; + SelectBackMidFront1.Enabled := Mode = mMap; + SelectCurrentTile1.Enabled := Mode = mMap; + + ShowGrid1.Enabled := Mode = mMap; + ShowMapCodes1.Enabled := Mode = mMap; + ShowBounds1.Enabled := Mode = mMap; + ClearArea1.Enabled := Mode = mMap; + + Properties1.Enabled := TRUE; +// MapProperties1.Enabled := Mode = mMap; + + DrawingInMap := FALSE; + ReadingFromMap := FALSE; + + // MapEditor1.Checked := Sender = MapEditor1; + // TileEditor1.Checked := Sender = TileEditor1; + + + ShowTileGrid1.Enabled := Mode = mTile; + + ClearUndo; + + if Mode = mTile then + begin + StartEdit (TRUE); + + AnimationTimer.Enabled := Animate1.Checked; + end + else + begin + MapTabChange (nil); + ClipTabChange (nil); + SeqTabChange (nil); + end; + + + if Mode = mTile then + begin + MoveMapLeft1.Enabled := FALSE; // 2.53 + MoveMapRight1.Enabled := FALSE; + NextMap1.Enabled := FALSE; + PreviousMap1.Enabled := FALSE; + end; + + + MapModeButton.Down := Mode = mMap; + MapModeButton.Enabled := Mode <> mMap; + TileModeButton.Down := Mode = mTile; + TileModeButton.Enabled := Mode <> mTile; + + + UndoButton.Visible := Mode = mTile; + RedoButton.Visible := Mode = mTile; + ToolButton3.Visible := Mode = mTile; + + NewTileButton.Visible := Mode = mTile; + ColorMatchButton.Visible := Mode = mTile; + ReplaceColorsButton.Visible := Mode = mTile; + ToolButton5.Visible := Mode = mTile; + + AnimateButton.Visible := Mode = mTile; + + ShowStatusInfo; + + ShowMapLayer1.Enabled := Mode = mMap; // 2.54 + if Mode = mMap then + begin + ShowBackLayer.Checked := TRUE; + ShowMidLayer.Checked := TRUE; + ShowFrontLayer.Checked := TRUE; + end; + + // 3.00 + //HistoryPanel.Enabled := Mode = mTile; + HistoryPanel.Visible := Mode = mTile; + +end; + +procedure TMainForm.BackgroundColor1Click(Sender: TObject); +begin + ColorDialog.Color := Background.Brush.Color; + if ColorDialog.Execute then + begin + SetBackgroundColor (ColorDialog.Color, FALSE); + if (Mode = mMap) and (MapTab.TabIndex <> -1) then + MapTabChange (Sender); + end; +end; + +procedure TMainForm.CopyTiles1Click(Sender: TObject); + var + i, j: Integer; + ovr, str, scaler, bnds: Boolean; +begin + with CopyTilesForm do + begin + Src.Text := TileTab[Tab.TabIndex].id; + Src.Items := Tab.Tabs; + Dst.Text := TileTab[Tab.TabIndex].id; + Dst.Items := Tab.Tabs; + with TileTab[Tab.TabIndex] do + begin + StartTile.Value := tbr.Current + 1; + TileCount.Value := tbr.TileCount - tbr.Current; + end; + ShowModal; + if Result then + begin + i := Src.Items.IndexOf (Src.Text); + j := Src.Items.IndexOf (Dst.Text); + if (i >= 0) and (j >= 0) { and (TileCount.Value > 0) } then // 2.51 bug fix + begin + MainForm.ProgressPanel.Visible := TRUE; + + ovr := Overwrite.Enabled and Overwrite.Checked; + str := Stretch.Enabled and Stretch.Checked; + scaler := UseScaler.Enabled and UseScaler.Checked; + bnds := CopyBounds.Enabled and CopyBounds.Checked; + + if (i = j) and (StartTile.Value = DstStartTile.Value) then + ShowMessage ('Nothing to do.') + else + CopyTiles (TileTab[i].tbr, + TileTab[j].tbr, + StartTile.Value - 1, + TileCount.Value, + DstStartTile.Value - 1, + ovr, str, scaler, bnds, + i = j, + ProgressBar); + + // mainform.caption := debugstr; + + MainForm.ProgressPanel.Visible := FALSE; + + Tab.TabIndex := j; + TabChange (Sender); + StartEdit (TRUE); + Modified := TRUE; + end; + + end; + end; +end; + +procedure TMainForm.InsertNewTile1Click(Sender: TObject); +begin + UpdateBmp (TRUE); + InsertNewTile (TileTab[Tab.TabIndex].tbr, FALSE); + UpdateTileBitmap; + Modified := TRUE; + StartEdit (TRUE); +end; + +procedure TMainForm.PreviousTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if Current > 0 then + begin + Dec (Current); + StartEdit (FALSE); + end; + DrawCursor; +end; + +procedure TMainForm.NextTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if Current < TileCount - 1 then + begin + Inc (Current); + StartEdit (FALSE); + end + else + if Mode = mTile then + NewTile1Click (Sender); + DrawCursor; +end; + +procedure TMainForm.FirstTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + Current := 0; + StartEdit (FALSE); +end; + +procedure TMainForm.LastTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + Current := TileCount - 1; + StartEdit (FALSE); +end; + +procedure TMainForm.StretchPaste1Click(Sender: TObject); + var + i, j, x, y: Integer; + X1, Y1, X2, Y2: Integer; +begin + if Mode = mTile then + begin + if Clipboard.HasFormat(CF_BITMAP) then + begin + X1 := BORDER_W; + Y1 := BORDER_H; + X2 := X1 + W; + Y2 := Y1 + H; + + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + X1 := TileSelX1; + Y1 := TileSelY1; + X2 := TileSelX2; + Y2 := TileSelY2; + end; + + SaveUndo ('Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + SetStretchBltMode(Bmp.Canvas.Handle, HALFTONE); + with ClipBmp do + Bmp.Canvas.CopyRect (Rect (X1, Y1, X2, Y2), + ClipBmp.Canvas, MakeRect (0, 0, ClipBmp.Width, ClipBmp.Height)); + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; + end; + end; + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + y := (j - Top) mod ClipH; + if ClipH > 2 then + y := 1 + ((j - Top) mod (ClipH - 2)); + x := (i - Left) mod ClipW; + if ClipW > 2 then + x := 1 + ((i - Left) mod (ClipW - 2)); + if Top < Bottom then + begin + if j = Top then y := 0; + if j = Bottom then y := ClipH - 1; + end; + if Left < Right then + begin + if i = Left then x := 0; + if i = Right then x := ClipW - 1; + end; + lmp^.Map[j, i] := clip^.Map[y, x]; + end; + Selection := FALSE; + Modified := TRUE; + UpdateMapRegion(Area); + end; +end; + +procedure TMainForm.ToggleMultiple1Click(Sender: TObject); + var + F, L: Integer; +begin + F := LastFromToFirst; + L := LastFromToLast; + LastFromToFirst := FromToFirst; + LastFromToLast := FromToLast; + + if FromToFirst = FromToLast then + begin + if F <> L then + begin + FromToFirst := F; + FromToLast := L; + end + else + begin + FromToFirst := 0; + FromToLast := MAX_FROM_TO - 1; + end; + end + else + begin + if F = L then + begin + FromToFirst := F; + FromToLast := L; + end + else + begin + FromToFirst := F + (L - F) div 2; + FromToLast := FromToFirst; + end; + end; + FromTo.Repaint; +end; + + +procedure TMainForm.SelectBackMidFront(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + + procedure SetBevel (var p: TPanel; Down: Boolean); + begin + if Down then + begin + p.BevelInner := bvLowered; + p.BevelOuter := bvLowered; + end + else + begin + p.BevelInner := bvRaised; + p.BevelOuter := bvRaised; + end; + end; + + var + LastBMF: Integer; +begin + with TileTab[Tab.TabIndex].tbr do + begin + LastBMF := BackMidFront; + if (Sender = pBack) or (Sender = bmpBack) then + BackMidFront := -1 + else if (Sender = pFront) or (Sender = bmpFront) then + BackMidFront := 1 + else + BackMidFront := 0; + + if Button = mbLeft then + SelectCurrentTile (Current) + else + if BackMidFront = LastBMF then + SelectCurrentTile (-1); + end; + ShowSelectedTile; +end; + +procedure TMainForm.ShowSelectedTile; + + procedure SetBevel (var p: TPanel; Down: Boolean); + begin + if Down then + begin + p.BevelInner := bvLowered; + p.BevelOuter := bvLowered; + end + else + begin + p.BevelInner := bvRaised; + p.BevelOuter := bvRaised; + end; + end; + +begin + with TileTab[Tab.TabIndex].tbr do + begin + SetBevel (pBack, BackMidFront = -1); + SetBevel (pMid, BackMidFront = 0); + SetBevel (pFront, BackMidFront = 1); + end; + DrawCurrentTile; +end; + +procedure TMainForm.DrawTile (TabIndex, N: Integer; + var bmp: TImage; + var Mir: Boolean; + var Ups: Boolean; + var Rot: Boolean; + var FullBmp: TImage); + var + Tile: Integer; + RR: TRect; + m, u, r: Boolean; + MirW, UpsH: Integer; + i, j: Integer; + TmpBmp1, TmpBmp2: TBitmap; + +begin + with TileTab[TabIndex].tbr do + begin + + if n = -1 then + begin + Mir := FALSE; + Ups := FALSE; + Rot := FALSE; + FillBitmap (bmp, TRANS_COLOR); + end + else + begin + m := n and MIRROR_MASK = MIRROR_MASK; + u := n and UPS_MASK = UPS_MASK; + r := n and ROTATE_MASK = ROTATE_MASK; + Mir := m; + Ups := u; + Rot := r; + MirW := Byte (m); + UpsH := Byte (u); + Tile := n and TILE_MASK; + RR := Rect (MirW * (W - 1), + UpsH * (H - 1), + W - MirW * (W + 1), + H - UpsH * (H + 1)); + bmp.Canvas.CopyRect (RR, TileBitmap.Canvas, + MakeRect (tile * W, 0, W, H)); + + if r then + begin + TmpBmp1 := TBitmap.Create; + SetStretchBltMode(TmpBmp1.Canvas.Handle, HALFTONE); + with TmpBmp1 do + begin + PixelFormat := pf24bit; + Width := W; + Height := H; + Transparent := TRUE; + TransparentColor := TRANS_COLOR; + for j := 0 to Height - 1 do + for i := 0 to Width - 1 do + Canvas.Pixels[i, j] := Bmp.Canvas.Pixels[i, j]; + end; + TmpBmp2 := TBitmap.Create; + SetStretchBltMode(TmpBmp2.Canvas.Handle, HALFTONE); + with TmpBmp2 do + begin + PixelFormat := pf24bit; + Width := H; + Height := W; + Transparent := TRUE; + TransparentColor := TRANS_COLOR; + for j := 0 to Height - 1 do + for i := 0 to Width - 1 do + Canvas.Pixels[i, j] := TRANS_COLOR; + Canvas.StretchDraw (Rect (0, 0, H, W), TmpBmp1); + end; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + bmp.Canvas.Pixels[i, j] := TmpBmp2.Canvas.Pixels[j, W - 1 - i]; + TmpBmp1.Free; + TmpBmp2.Free; + end; + + FullBMP.Canvas.Draw (0, 0, bmp.Picture.Graphic); + end; + end; +end; + + +procedure TMainForm.DrawCurrentTile; + var + m, u, r: Boolean; + s: string; + tx, ty, tw, th: Integer; + ti: Integer; + ov: Integer; +begin + FillBitmap (bmpPreview, BackGround.Brush.Color); + + ti := Tab.TabIndex; + with TileTab[ti].tbr do + begin + DrawTile (ti, mcr.Back, bmpBack, m, u, r, bmpPreview); + bMir.Down := m; + bUps.Down := u; + bRot.Down := r; + DrawTile (ti, mcr.Mid, bmpMid, m, u, r, bmpPreview); + mMir.Down := m; + mUps.Down := u; + mRot.Down := r; + DrawTile (ti, mcr.Front, bmpFront, m, u, r, bmpPreview); + fMir.Down := m; + fUps.Down := u; + fRot.Down := r; + + ov := TileTab[Tab.TabIndex].tbr.Overlap; + if (ShowBounds1.Checked) and (mcr.Bounds <> 0) then + DrawBounds (bmpPreview.Canvas, 0, ov, W, H, 1, mcr.Bounds, clWhite); + + if (ShowMapCodes1.Checked) and (mcr.MapCode <> 0) then + begin + FillBitmap (bmp1, TRANS_COLOR); + with bmp1.Picture.Bitmap.Canvas do + begin + s := Hex2 (mcr.MapCode); + tw := TextWidth (s); + th := TextHeight (s); + tx := W div 2 - tw div 2; + ty := H div 2 - th div 2; + Font.Color := clBlack; + TextOut (tx, ty, s); + bmpPreview.Picture.Bitmap.Canvas.Draw (0, 0, bmp1.Picture.Bitmap); + Font.Color := clWhite; + TextOut (tx, ty, s); + bmpPreview.Picture.Bitmap.Canvas.Draw (-1, -1, bmp1.Picture.Bitmap); + end; + end; + + end; + + BoundBox.Repaint; + if Mode = mMap then + with MapCodeButton do + Caption := Hex2 (TileTab[Tab.TabIndex].tbr.mcr.MapCode); +end; + +procedure TMainForm.SelectCurrentTile (n: Integer); + var + i, j, k, Bnds: Integer; +begin + with TileTab[Tab.TabIndex].tbr do + begin + Bnds := 0; + if n < TileCount then + begin + k := n; + Bnds := GetBound (TileTab[Tab.TabIndex].tbr, -1); + end + else + k := -1; + if k = -1 then + case BackMidFront of + -1: if HasCurrentBounds (mcr.Back) then + MainForm.Bounds := 0; + 0: if HasCurrentBounds (mcr.Mid) then + MainForm.Bounds := 0; + 1: if HasCurrentBounds (mcr.Front) then + MainForm.Bounds := 0; + end + else + if Bnds <> 0 then + if Mode = mTile then + mcr.Bounds := Bnds + else + MainForm.Bounds := Bnds; + case BackMidFront of + -1: mcr.Back := k; + 0: mcr.Mid := k; + 1: mcr.Front := k; + end; + mcr.MapCode := 0; + + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + with lmp^.Map[j, i] do + case BackMidFront of + -1: Back := k; + 0: Mid := k; + 1: Front := k; + end; + end; + Selection := FALSE; + UpdateMapRegion(Area); + end; + + end; +end; + + +procedure TMainForm.MirTileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + with Sender as TSpeedButton do + Down := TRUE; + +end; + +function TMainForm.HasCurrentBounds (Tile: SmallInt): Boolean; + var + i: Integer; + b: Integer; + m, u: Boolean; +begin + Result := FALSE; + if Tile <> -1 then + begin + i := Tile and TILE_MASK; + m := Tile and MIRROR_MASK <> 0; + u := Tile and UPS_MASK <> 0; + b := GetBound (TileTab[Tab.TabIndex].tbr, i); + if m then + HFlipBounds (b); + if u then + VFlipBounds (b); + Result := b = Bounds; + end; +end; + +procedure TMainForm.fUpsClick(Sender: TObject); + + procedure Flip (m, u, r: Boolean; var Tile: SmallInt); + begin + if Tile <> -1 then + begin + if m then + begin + if HasCurrentBounds (Tile) then + HFlipBounds (Bounds); + Tile := SmallInt (Word (Tile) xor MIRROR_MASK); + end; + if u then + begin + if HasCurrentBounds (Tile) then + VFlipBounds (Bounds); + Tile := SmallInt (Word (Tile) xor UPS_MASK); + end; + if r then + begin + if HasCurrentBounds (Tile) then + RotateBounds (Bounds, -90); + Tile := SmallInt (Word (Tile) xor ROTATE_MASK); + end; + end; + end; + +begin + with TileTab[Tab.TabIndex].tbr.mcr do + begin + Flip (Sender = bMir, Sender = bUps, Sender = bRot, Back); + Flip (Sender = mMir, Sender = mUps, Sender = mRot, Mid); + Flip (Sender = fMir, Sender = fUps, Sender = fRot, Front); + end; + DrawCurrentTile; +end; + +procedure FlipBit (var i: SmallInt; Mask: Integer); +begin + if i <> -1 then + i := i xor SmallInt (Mask); +end; + +procedure TMainForm.MirSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + var + mcr: MapCellRec; + i: Integer; +begin + mcr := mcr1; + mcr1 := mcr2; + mcr2 := mcr; + + i := mcr1.Bounds; + HFlipBounds (i); + mcr1.Bounds := i; + with mcr1 do + begin + FlipBit (Back, MIRROR_MASK); + FlipBit (Mid, MIRROR_MASK); + FlipBit (Front, MIRROR_MASK); + end; + + if MirBoth then + begin + i := mcr2.Bounds; + HFlipBounds (i); + mcr2.Bounds := i; + with mcr2 do + begin + FlipBit (Back, MIRROR_MASK); + FlipBit (Mid, MIRROR_MASK); + FlipBit (Front, MIRROR_MASK); + end; + end; +end; + +procedure TMainForm.UpsSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + var + mcr: MapCellRec; + i: Integer; +begin + mcr := mcr1; + mcr1 := mcr2; + mcr2 := mcr; + + i := mcr1.Bounds; + VFlipBounds (i); + mcr1.Bounds := i; + with mcr1 do + begin + FlipBit (Back, UPS_MASK); + FlipBit (Mid, UPS_MASK); + FlipBit (Front, UPS_MASK); + end; + + if MirBoth then + begin + i := mcr2.Bounds; + VFlipBounds (i); + mcr2.Bounds := i; + with mcr2 do + begin + FlipBit (Back, UPS_MASK); + FlipBit (Mid, UPS_MASK); + FlipBit (Front, UPS_MASK); + end; + end; +end; + +procedure TMainForm.Horizontal2Click(Sender: TObject); + var + i, j, k, l: Integer; +begin + if Mode <> mMap then + Exit; + if Selection then + begin + k := (Area.Right - Area.Left + 2) div 2; + for j := Area.Top to Area.Bottom do + for i := Area.Left to (Area.Left + k - 1) do + begin + l := Area.Right - (i - Area.Left); + MirSwap (lmp^.Map[j, i], lmp^.Map[j, l], i <> l); + end; + Modified := TRUE; + // Selection := FALSE; + UpdateMapRegion(Area); + end + else + with TileTab[Tab.TabIndex].tbr do + case BackMidFront of + -1: fUpsClick (bMir); + 0: fUpsClick (mMir); + 1: fUpsClick (fMir); + end; +end; + +procedure TMainForm.Vertical2Click(Sender: TObject); + var + i, j, k, l: Integer; +begin + if Mode <> mMap then + Exit; + if Selection then + begin + k := (Area.Bottom - Area.Top + 2) div 2; + for j := Area.Top to Area.Top + k - 1 do + for i := Area.Left to Area.Right do + begin + l := Area.Bottom - (j - Area.Top); + UpsSwap (lmp^.Map[j, i], lmp^.Map[l, i], j <> l); + end; + Modified := TRUE; + // Selection := FALSE; + UpdateMapRegion(Area); + end + else + with TileTab[Tab.TabIndex].tbr do + case BackMidFront of + -1: fUpsClick (bUps); + 0: fUpsClick (mUps); + 1: fUpsClick (fUps); + end; +end; + +procedure TMainForm.SelectCurrentTile1Click(Sender: TObject); +begin + SelectCurrentTile (TileTab[Tab.TabIndex].tbr.Current); + DrawCurrentTile; +end; + +procedure TMainForm.Next1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Inc (BackMidFront, 2); + BackMidFront := BackMidFront mod 3; + Dec (BackMidFront); + end; + ShowSelectedTile; +end; + +procedure TMainForm.Previous1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + BackMidFront := (BackMidFront + 3) mod 3; + Dec (BackMidFront); + end; + ShowSelectedTile; +end; + +procedure TMainForm.ToggleTileMapEditor1Click(Sender: TObject); +begin + if Mode = mTile then + SetEditorMode (mMap) + else + if Mode = mMap then + SetEditorMode (mTile); +end; + +procedure TMainForm.MapCodeButtonClick(Sender: TObject); + var + i, j: Integer; +begin + MapCode.Value := TileTab[Tab.TabIndex].tbr.mcr.MapCode; + MapCode.ShowModal; + TileTab[Tab.TabIndex].tbr.mcr.MapCode := MapCode.Value; + // if MapCode.Value < $A then + MapCodeButton.Caption := Hex2 (MapCode.Value); + ShowSelectedTile; + + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + lmp^.Map[j, i].MapCode := MapCode.Value; + { RD: Clear selection; redraw area } + Selection := FALSE; + UpdateMapRegion(Area); + end; + + // else + // MapCodeButton.Caption := '0x' + Hex2 (MapCode.Value); +end; + +procedure TMainForm.Map1Click(Sender: TObject); +begin + with NewForm do + begin + NewMode := nmNewMap; + CreateNew := TRUE; + DefaultName := NewMapName; + CanChangeSize := TRUE; + DefaultOverlap := TileTab[Tab.TabIndex].tbr.Overlap; + ShowModal; + + if Result then + if MapTab.Tabs.IndexOf (Identifier.Text) <> -1 then // bug fix + Msg ('Name ' + Identifier.Text + ' already in use.') + else + begin + NewMap (TileTab[Tab.TabIndex].tbr, Identifier.Text, NH.Value, NV.Value); + + MapTab.TabIndex := MapTab.Tabs.Add (Identifier.Text); + MapTabChange (Sender); + + with TileTab[Tab.TabIndex].tbr do + Maps.aMaps[Maps.CurMap].SkipExport := Skip.Checked; // 2.2 + + if Mode = mTile then + SetEditorMode (mMap); + end; + end; +end; + +procedure TMainForm.ShowUsedColors1Click(Sender: TObject); + var + bmp: TBitmap; + x, y: Integer; + i, j, k: Integer; + Found: Boolean; + ai: array of Integer; + ColorMask: Integer; +begin + if N61.Checked then + ColorMask := $FCFCFC + else + if N71.Checked then + ColorMask := $FEFEFE + else + ColorMask := $FFFFFF; + with ShowUsedColors1 do + begin + Checked := not Checked; + if Checked then + begin + with ProgressBar do + begin + Min := 0; + with TileTab[Tab.TabIndex].tbr.TileBitmap do + Max := Width * Height; + Position := Min; + end; + ProgressPanel.Visible := TRUE; + bmp := TBitmap.Create; + SetStretchBltMode(bmp.Canvas.Handle, HALFTONE); + with bmp do + begin + PixelFormat := pf24bit; + Width := 1; + Height := 1; + Canvas.Pixels[0, 0] := TRANS_COLOR; + k := 1; + SetLength (ai, k); + ai[0] := TRANS_COLOR; + with TileTab[Tab.TabIndex].tbr.TileBitmap do + for y := 0 to Height - 1 do + begin + for x := 0 to Width - 1 do + begin + i := Canvas.Pixels[x, y]; + if i <> TRANS_COLOR then + i := (i and ColorMask); + Found := FALSE; + for j := 0 to k - 1 do + if not Found then + // if bmp.Canvas.Pixels[0, j] = i then + if ai[j] = i then + Found := TRUE; + if not Found then + begin + Inc (k); + SetLength (ai, k); + ai[k - 1] := i; + bmp.Height := k; + bmp.Canvas.Pixels[0, k - 1] := i; + end; + if x mod 16 = 0 then + ProgressBar.Position := y * Width + x; + end; + end; + Canvas.Pixels[0, 0] := BackGround.Brush.Color; + SetLength (ai, 0); + end; + ProgressPanel.Visible := FALSE; + UsedColorsImage.Picture.Bitmap := bmp; + UsedColors.Hint := IntToStr (bmp.Height) + ' colors used'; + UsedColors.ShowHint := TRUE; + bmp.Free; + UsedColorsImage.Stretch := TRUE; + UsedColors.Visible := TRUE; + MainForm.Resize; + end + else + HideUsedColors; + end; + UsedColorSelect := FALSE; +end; + +procedure TMainForm.HideUsedColors; +begin + if UsedColors.Visible then + begin + UsedColors.Visible := FALSE; + ShowUsedColors1.Checked := FALSE; + ShowCurrentPalette1.Checked := FALSE; + MainForm.Resize; + end; + UsedColorSelect := FALSE; +end; + +procedure TMainForm.UsedColorsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + UsedColorSelect := TRUE; + UsedColorsImageMouseMove (Sender, Shift, X, Y); +end; + +procedure TMainForm.UsedColorsImageMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + var + c, j: Integer; +begin + with UsedColorsImage.Picture do + begin + j := y * Bitmap.Height div UsedColorsImage.Height; + c := Bitmap.Canvas.Pixels[0, j]; + ShowRGB (c); // 2.51 + end; + if UsedColorSelect then + SetColor (c, FALSE, FALSE) +end; + +procedure TMainForm.UsedColorsImageMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Color.Brush.Color = BackGround.Brush.Color then + SetBackGroundColor (Color.Brush.Color, TRUE); + UsedColorSelect := FALSE; +end; + +procedure TMainForm.MapProperties1Click(Sender: TObject); +begin + if MapTab.TabIndex > -1 then + with NewForm do + begin + NewMode := nmMapProperties; + CreateNew := FALSE; + DefaultName := MapTab.Tabs.Strings[MapTab.TabIndex]; + + with TileTab[Tab.TabIndex].tbr do + Skip.Checked := Maps.aMaps[Maps.CurMap].SkipExport; // 2.2 + + with lmp^ do + begin + NH.Value := Length (Map[0]); + NV.Value := Length (Map); + end; + CanChangeSize := TRUE; + DefaultOverlap := TileTab[Tab.TabIndex].tbr.Overlap; + + // todo: something causes a breakpoint in ntdll.dll here + ShowModal; + + if Result then + begin + if Identifier.Text <> DefaultName then + if MapTab.Tabs.IndexOf (Identifier.Text) <> -1 then // bug fix + begin + Msg ('Name ' + Identifier.Text + ' already in use.'); + Identifier.Text := DefaultName; + end; + + with lmp^ do + begin + Id := Identifier.Text; + SetMapSize (Map, NH.Value, NV.Value); + end; + MapTab.Tabs.Strings[MapTab.TabIndex] := Identifier.Text; + MapTabChange (Sender); + + with TileTab[Tab.TabIndex].tbr do + Maps.aMaps[Maps.CurMap].SkipExport := Skip.Checked; // 2.2 + + if Mode = mTile then + SetEditorMode (mMap); + { RD: Redraw whole map (with altered dimensions) } + UpdateMap; + end; + end; + +end; + +procedure TMainForm.GetMCRTile (var MCR: MapCellRec; var Tile: Integer; + var Mir: Boolean; var Ups: Boolean); +begin + with MCR do + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: Tile := Back; + 0: Tile := Mid; + 1: Tile := Front; + end; + if Tile <> -1 then + begin + Mir := (Tile and MIRROR_MASK) <> 0; + Ups := (Tile and UPS_MASK) <> 0; + Tile := Tile and TILE_MASK; + end + else + begin + Mir := FALSE; + Ups := FALSE; + end; +end; + +procedure TMainForm.SetMCRTile (var MCR: MapCellRec; Tile: Integer; + Mir, Ups: Boolean); +begin + if Tile <> -1 then + begin + if Mir then Tile := Tile or MIRROR_MASK; + if Ups then Tile := Tile or UPS_MASK; + end; + with MCR do + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: Back := SmallInt (Tile); // 2.54: bugfix (Range check error) + 0: Mid := SmallInt (Tile); + 1: Front := SmallInt (Tile); + end; + Modified := TRUE; +end; + +procedure TMainForm.AddMCR (var MCR: MapCellRec; n: Integer); + var + Tile: Integer; + m, u: Boolean; + Max: Integer; +begin + GetMCRTile (MCR, Tile, m, u); + if Tile < 0 then + begin + Tile := TileTab[Tab.TabIndex].tbr.Current; + m := FALSE; + u := FALSE; + end; + Inc (Tile, n); + Max := TileTab[Tab.TabIndex].tbr.TileCount; /// - 1; + if Max < 1 then + Max := 1; + Tile := Tile mod Max; + SetMCRTile (MCR, Tile, m, u); +end; + +procedure TMainForm.DrawMap (Area: TRect; ExportingImage: Boolean; Clp, Sq: Boolean); + var + i, j, tx, ty, tw, th, tmpw, tmph, min_i, min_j, ii, jj: Integer; + mcr: MapCellRec; + m, u, r: Boolean; + DrawAll: Boolean; + s: string; + X1, Y1, X2, Y2, EY1, EY2: Integer; + bmpBitmap: TBitmap; + ptr: LayerMapPtr; + ov: Integer; + Selected, CellSelected: Boolean; + CL1, CL2: Integer; +begin + + min_i := 0; + min_j := 0; + + Selected := false; + if Selection then Selected := true; + if DrawingInMap and (MapDrawingTool in [mdtFilledRect, mdtRect, mdtZOrder]) then + Selected := true; + if Sq or Clp then + Selected := false; + + SkipDraw := TRUE; + DrawAll := (Area.Left = 0) and (Area.Top = 0) and + (Area.Right = -1) and (Area.Bottom = -1); + + ov := TileTab[Tab.TabIndex].tbr.Overlap; + + if Sq then + begin + ptr := seq; + bmpBitmap := SeqBitmap.Picture.Bitmap; + DrawAll := FALSE; + end + else + begin + if Clp then + begin + ptr := clip; + bmpBitmap := ClipBitmap.Picture.Bitmap; + end + else + begin + ptr := lmp; + if ExportingImage then // 2.5 + bmpBitmap := bmpMapImage + else + bmpBitmap := bmpMap; + end; + end; + + if ptr <> nil then + with ptr^ do + if Length (Map) > 0 then + begin + if not Sq then + begin + CurMapH := Length (Map); + CurMapW := Length (Map[0]); + if Clp or ExportingImage then // 2.51 bug fix + begin + bmpBitmap.Width := CurMapW * W; + bmpBitmap.Height := CurMapH * (H - ov); + end + else + begin + bmpBitmap.Width := (VisibleMapRegion.Right - VisibleMapRegion.Left + 1) * W; + bmpBitmap.Height := (VisibleMapRegion.Bottom - VisibleMapRegion.Top + 1) * (H - ov); + end; + end; + + // ResizeBitmap (bmpMap); + if DrawAll then + begin + X1 := 0; + Y1 := 0; + X2 := CurMapW - 1; + Y2 := CurMapH - 1; + end + else + begin + X1 := Area.Left; + Y1 := Area.Top; + X2 := min(Area.Right, CurMapW - 1); + Y2 := min(Area.Bottom, CurMapH - 1); + end; + + if not (Clp or Sq or ExportingImage) then // 2.51 bug fix + begin + X1 := max(X1, VisibleMapRegion.Left); + Y1 := max(Y1, VisibleMapRegion.Top); + X2 := min(X2, VisibleMapRegion.Right); + Y2 := min(Y2, VisibleMapRegion.Bottom); + min_i := VisibleMapRegion.Left; + min_j := VisibleMapRegion.Top; + end; + + EY1 := Y1; + EY2 := Y2; + + { + // 2.5 - removed + + if (not (Sq or Clp)) and (ov > 0) then + begin + if EY1 > 0 then Dec (EY1); + if EY2 < SizeOf ??? (map) then Inc (EY2); + end; + } + + ///* + + begin + for j := EY1 to EY2 do + for i := X1 to X2 do + // if DrawAll or Inside (i, j, Area) then + begin + mcr := map[j, i]; + CellSelected := Selected and Inside(i, j, Self.Area); + FillBitmap (bmp1, TRANS_COLOR); + if Sq then + FillBitmap (bmp2, BackGround.Brush.Color) + else + FillBitmap (bmp2, TRANS_COLOR); + + if ShowGrid1.Checked then + with bmp2.Picture.Bitmap.Canvas do + begin + CL1 := clBlack; + CL2 := clWhite; + + if MapGridX > 0 then // 2.54 + begin + if i mod MapGridX = 0 then CL1 := clRed; + if (i + 1) mod MapGridX = 0 then CL2 := clRed; + end; + if MapGridY > 0 then + begin + if j mod MapGridY = 0 then CL1 := clRed; + if (j + 1) mod MapGridY = 0 then CL2 := clRed; + end; + + if MapGridX > 0 then + for jj := ov to H - 1 do + begin + if i mod MapGridX = 0 then Pixels[0, jj] := clWhite; + if (i + 1) mod MapGridX = 0 then Pixels[W - 1, jj] := clBlack; + end; + + if MapGridY > 0 then + for ii := 0 to W - 1 do + begin + if j mod MapGridY = 0 then Pixels[ii, ov] := clWhite; + if (j + 1) mod MapGridY = 0 then Pixels[ii, H - 1] := clBlack; + end; + + Pixels[0, 0 + ov] := CL1; + Pixels[W - 1, H - 1] := CL2; + end; + + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then // 2.55 + begin + if CellSelected then + begin + if MapDrawingTool in [mdtFilledRect, mdtZOrder] then + begin + mcr := TileTab[Tab.TabIndex].tbr.mcr; + if MapDrawingTool in [mdtZOrder] then + AddMCR (mcr, i - X1 + (j - Y1) * (X2 - X1 + 1)); + end; + end; + if mcr.Back <> -1 then + if ShowBackLayer.Checked then + DrawTile (Tab.TabIndex, mcr.Back, bmp1, m, u, r, bmp2); + if mcr.Mid <> -1 then + if ShowMidLayer.Checked then + DrawTile (Tab.TabIndex, mcr.Mid, bmp1, m, u, r, bmp2); + if mcr.Front <> -1 then + if ShowFrontLayer.Checked then + DrawTile (Tab.TabIndex, mcr.Front, bmp1, m, u, r, bmp2); + end; + + if sq then + bmpBitmap.Canvas.CopyRect + (MakeRect (0, 0, W, H), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0, W, H)) + else + begin + + // if mcr.Bounds <> $FF then // 2.55 + // if mcr.Bounds <> 0 then + // if mcr.Bounds and $40 = 0 then // allow bounds with sequences + begin + if CellSelected then + if MapDrawingTool in [mdtRect] then + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, SelBmp.Picture.Bitmap); + + if ShowBounds1.Checked then + DrawBounds (bmp2.Canvas, 0, ov, W, H, 1, mcr.Bounds, clWhite); + end; + + if (ShowMapCodes1.Checked and (mcr.MapCode <> 0)) or + // (mcr.Bounds = $FF) then // 2.55 + // (mcr.Bounds < 0) then + (mcr.Bounds and $40 <> 0) then + begin + FillBitmap (bmp1, TRANS_COLOR); + with bmp1.Picture.Bitmap.Canvas do + begin + s := Hex2 (mcr.MapCode); + tw := TextWidth (s); + th := TextHeight (s); + tx := W div 2 - tw div 2; + ty := ov + (H - ov) div 2 - th div 2; + Font.Color := clBlack; + TextOut (tx, ty, s); + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, bmp1.Picture.Bitmap); + Font.Color := clWhite; + // if mcr.Bounds = $FF then + // if mcr.Bounds < 0 then // 2.55 + if mcr.Bounds and $40 <> 0 then + Font.Color := clRed; + TextOut (tx, ty, s); + bmp2.Picture.Bitmap.Canvas.Draw (-1, -1, bmp1.Picture.Bitmap); + end; + end; + + if ExportingImage then + // if (not ShowMapCodes1.Checked) and (mcr.Bounds = $FF) then // 2.55 + if (not ShowMapCodes1.Checked) and (mcr.Bounds and $40 <> 0) then + begin + SeqTab.TabIndex := mcr.MapCode; + SkipDraw := FALSE; + SeqTabChange (nil); + SkipDraw := TRUE; + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, SeqBitmap.Picture.Bitmap); + end; + + bmp1.Picture.Bitmap.Canvas.CopyRect + (MakeRect (0, 0, W, H), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0, W, H)); + + FillBitmap (bmp2, BackGround.Brush.Color); + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, bmp1.Picture.Bitmap); + + if (j >= Y1) and (j <= Y2) then + bmpBitmap.Canvas.CopyRect + (MakeRect ((i - min_i) * W, (j - min_j) * (H - ov), W, H - ov), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0 + ov, W, H)); + + if (ov > 0) then + if (j > Y1) or (not CellSelected) then + with bmp1.Picture.Graphic do + begin + tmpw := Width; + tmph := Height; + Width := W; + Height := ov; + bmpBitmap.Canvas.Draw + ((i - min_i) * W, (j - min_j) * (H - ov) - ov, + bmp1.Picture.Graphic); + Width := tmpw; + Height := tmph; + end; + + end; + + end; + end; + end; + + SkipDraw := FALSE; +end; + +procedure TMainForm.ZoomMap; + var + z1, z2: Integer; +begin +// MapDisplay.Width := bmpMap.Width * ZOOM_FACTOR div Zoom; +// MapDisplay.Height := bmpMap.Height * ZOOM_FACTOR div Zoom; + + ZoomIn1.Enabled := (Zoom > 1); + ZoomOut1.Enabled := (Zoom < MAX_ZOOM); + z1 := ZOOM_FACTOR; + z2 := Zoom; + if (z1 mod 3 = 0) and (z2 mod 3 = 0) then + begin + z1 := z1 div 3; + z2 := z2 div 3; + end; + if (z1 mod 2 = 0) and (z2 mod 2 = 0) then + begin + z1 := z1 div 2; + z2 := z2 div 2; + end; + StatusBar.Panels[4].Text := Format ('%d:%d', [z1, z2]); +end; + +procedure TMainForm.MapTabChange(Sender: TObject); + var + tw, th: integer; +begin + // SeqTimer.Enabled := FALSE; + if MapTab.TabIndex >= 0 then + begin + MapDisplay.Visible := TRUE; + + // 2.42 + with TileTab[Tab.TabIndex].tbr.Maps.aMaps[MapTab.TabIndex] do + begin + CurMapH := Length (Map); + CurMapW := Length (Map[0]); + end; + with TileTab[Tab.TabIndex].tbr do + begin + tw := W * ZOOM_FACTOR div Zoom; + th := (H - Overlap) * ZOOM_FACTOR div Zoom; + end; + MapDisplay.Width := tw * CurMapW; + MapDisplay.Height := th * CurMapH; + + ZoomIn1.Enabled := (Zoom > 1); + ZoomOut1.Enabled := (Zoom < MAX_ZOOM); + + UpdateMap; + end + else + MapDisplay.Visible := FALSE; + + ShowStatusInfo; // 2.53 + + Selection := FALSE; + Area := Rect (0, 0, 0, 0); +end; + +procedure TMainForm.ShowGrid1Click(Sender: TObject); +begin + ShowGrid1.Checked := not ShowGrid1.Checked; + if ShowGrid1.Checked then + ShowGrid1.Tag := ShowGrid1.Tag + 1; + UpdateMap; +end; + +procedure TMainForm.bmpMapMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + MapX, MapY: Integer; + ov: Integer; +begin + ov := TileTab[Tab.TabIndex].tbr.Overlap; + ShiftState := Shift; + MapX := (X * Zoom div ZOOM_FACTOR) div W; + MapY := (Y * Zoom div ZOOM_FACTOR) div (H - ov); + if MapDrawingTool in [mdtRect] then + if Selection then + begin + Selection := FALSE; + UpdateMapRegion(Area); + end; + + if Button = mbLeft then + begin + // 2.55 - don't erase bounds + if (MapDrawingTool = mdtRect) then + begin + Bounds := 0; + BoundBox.RePaint; + end; + end; + + MapOrigin := Point (MapX, MapY); + Area := MakeRect (MapX, MapY, 0, 0); + LastArea := Area; + if Button = mbLeft then + begin + DrawingInMap := TRUE; + Modified := TRUE; + end; + if Button = mbRight then + ReadingFromMap := TRUE; + bmpMapMouseMove (Sender, Shift, X, Y); + MapPos := Point (-1, -1); +end; + +procedure TMainForm.bmpMapMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + var + MapX, MapY: Integer; + Tile: Integer; + m, u: Boolean; + ov: Integer; +begin + ov := TileTab[Tab.TabIndex].tbr.Overlap; + MapX := (X * Zoom div ZOOM_FACTOR) div W; + MapY := (Y * Zoom div ZOOM_FACTOR) div (H - ov); + StatusBar.Panels[1].Text := Format ('(%d, %d)', [MapX, MapY]); + // ExtendArea (Area, MapX, MapY); + if lmp <> nil then + if (MapX >= 0) and (MapX < CurMapW) and + (MapY >= 0) and (MapY < CurMapH) then + with lmp^ do + begin + if DrawingInMap then + begin + if MapDrawingTool = mdtPoint then + begin + if ssShift in ShiftState then + begin + GetMCRTile (TileTab[Tab.TabIndex].tbr.mcr, Tile, m, u); + + SetMCRTile (lmp^.Map[MapY, MapX], Tile, m, u); + end + else + lmp^.Map[MapY, MapX] := TileTab[Tab.TabIndex].tbr.mcr; + { RD: Redraw new tile } + UpdateMapRegion(Area); + Area := MakeRect (MapX, MapY, 0, 0); + end; + + if MapDrawingTool in [mdtFilledRect, mdtRect, mdtZOrder] then + begin + if (MapX <> MapPos.X) or (MapY <> MapPos.Y) then + begin + Area := MakeArea (MapOrigin.X, MapOrigin.Y, MapX, MapY); + if MapPos.X = -1 then LastArea := Area; + MapPos := Point (MapX, MapY); + UpdateMapRegion(Rect(min(Area.Left, LastArea.Left), + min(Area.Top, LastArea.Top), + max(Area.Right, LastArea.Right), + max(Area.Bottom, LastArea.Bottom))); + LastArea := Area; + end; + end; + + end; + + if ReadingFromMap then + begin + TileTab[Tab.TabIndex].tbr.mcr := lmp^.Map[MapY, MapX]; + Bounds := TileTab[Tab.TabIndex].tbr.mcr.Bounds; + ShowSelectedTile; + + + // 2.5 - go to selected tile + Tile := -1; + with TileTab[Tab.TabIndex].tbr.mcr do + begin + if Front <> -1 then + Tile := Front and TILE_MASK + else + if Mid <> -1 then + Tile := Mid and TILE_MASK + else + if Back <> -1 then + Tile := Back and TILE_MASK; + end; + + if Tile <> -1 then + begin + with TileTab[Tab.TabIndex].tbr do + Current := Tile; + StartEdit (FALSE); + end; + + end; + + end; + + ShowStatusInfo; +end; + +function TMainForm.CombineMCR (OldMCR, NewMCR: MapCellRec): MapCellRec; + var + Tile: Integer; + m, u: Boolean; + mcr: MapCellRec; +begin + mcr := OldMCR; + GetMCRTile (NewMCR, Tile, m, u); + SetMCRTile (mcr, Tile, m, u); + CombineMCR := mcr; +end; + +procedure TMainForm.bmpMapMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + i, j: Integer; + mcr: MapCellRec; +begin + if Button = mbLeft then + begin + DrawingInMap := FALSE; + if MapDrawingTool in [mdtFilledRect, mdtZOrder] then + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + mcr := TileTab[Tab.TabIndex].tbr.mcr; + if MapDrawingTool in [mdtZOrder] then + begin + AddMCR (mcr, i - Area.Left + (j - Area.Top) * + (Area.Right - Area.Left + 1)); + lmp^.Map[j, i] := CombineMCR (lmp^.Map[j, i], mcr); + end + else + lmp^.Map[j, i] := mcr; + end; + if MapDrawingTool in [mdtRect] then + begin + Selection := TRUE; + ClearMCR (TileTab[Tab.TabIndex].tbr.mcr); + Bounds := TileTab[Tab.TabIndex].tbr.mcr.Bounds; + ShowSelectedTile; + end + else + UpdateMapRegion(Area); + end; + if Button = mbRight then + ReadingFromMap := FALSE; +end; + +procedure TMainForm.SetMapDrawingTool(Sender: TObject); +begin + if Selection then + begin + UpdateMapRegion(Area); + Selection := FALSE; + end; + + if Sender = MapPointButton then + begin + MapDrawingTool := mdtPoint; + + + end; + + if Sender = MapRectButton then + begin + MapDrawingTool := mdtFilledRect; + + end; + + if Sender = ZOrderButton then + begin + MapDrawingTool := mdtZOrder; + + end; + + if Sender = BlockButton then + begin + MapDrawingTool := mdtRect; + + end; + + ShowStatusInfo; + Modified := TRUE; +end; + +procedure TMainForm.bmpPreviewMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Button = mbRight then + begin + ClearMCR (TileTab[Tab.TabIndex].tbr.mcr); + ShowSelectedTile; + end; +end; + +procedure TMainForm.ShowMapCodes1Click(Sender: TObject); +begin + ShowMapCodes1.Checked := not ShowMapCodes1.Checked; + UpdateMap; + ShowSelectedTile; +end; + +procedure TMainForm.ShowBounds1Click(Sender: TObject); +begin + ShowBounds1.Checked := not ShowBounds1.Checked; + UpdateMap; + ShowSelectedTile; +end; + +procedure TMainForm.ClearArea1Click(Sender: TObject); +begin + if Mode = mMap then + SelectCurrentTile (-1); +end; + +procedure TMainForm.ClipTabChange(Sender: TObject); + var + i: Integer; + ov: Integer; +begin + if ClipTab.TabIndex < 0 then + begin + clip := nil; + ClipBitmap.Visible := FALSE; + + Exit; + end; + ov := TileTab[Tab.TabIndex].tbr.Overlap; + clip := SelectClipMap (TileTab[Tab.TabIndex].tbr, ClipTab.TabIndex); + if clip <> nil then + begin + ClipH := Length (clip^.map); + if ClipH > 0 then + begin + ClipW := Length (clip^.map[0]); + + ClipBitmap.Visible := TRUE; + ClipBitmap.Width := ClipW * W; + ClipBitmap.Height := ClipH * (H - ov); + ResizeBitmap (ClipBitmap); + + { RD: draw clipped map } + DrawMap (Rect (0, 0, ClipW - 1, ClipH - 1), FALSE, TRUE, FALSE); + + ClipBitmap.Stretch := TRUE; + i := 1; + repeat + ClipBitmap.Width := ClipW * W div i; + ClipBitmap.Height := ClipH * (H - ov) div i; + Inc (i); + until (i >= 5) or + ((ClipBitmap.Width < ClipScrollBox.ClientWidth) and + (ClipBitmap.Height < ClipScrollBox.ClientHeight)); + + // ClipBitmap.Repaint; + end; + end; +end; + +procedure TMainForm.RandomFill1Click(Sender: TObject); + var + i, j, x, y: Integer; +begin + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + y := Random (ClipH); + x := Random (ClipW); + lmp^.Map[j, i] := clip^.Map[y, x]; + end; + { RD: clear selection } + Selection := FALSE; + UpdateMapRegion(Area); + end; + Modified := TRUE; +end; + +procedure TMainForm.RemoveMap1Click(Sender: TObject); // remove map + var + i: Integer; +begin + if MapTab.TabIndex > -1 then + begin + RemoveCurrentMap (TileTab[Tab.TabIndex].tbr); + with MapTab do + begin + i := TabIndex; + Tabs.Delete (i); + if i <= Tabs.Count - 1 then + TabIndex := i + else + TabIndex := Tabs.Count - 1; + end; + MapTabChange (Sender); + Modified := TRUE; + end; +end; + +procedure TMainForm.RemoveTileSet1Click(Sender: TObject); + var + i: Integer; +begin + if (Length (TileTab[Tab.TabIndex].tbr.Maps.aMaps) = 0) or + (Sender = nil) or + (MessageDlg ('One or more maps will be deleted. Continue?', + mtWarning, [mbYes, mbNo], 0) = mrYes) then + begin + FreeTBR (TileTab[Tab.TabIndex].tbr); + for i := Tab.TabIndex + 1 to Length (TileTab) - 1 do + TileTab[i - 1] := TileTab[i]; + SetLength (TileTab, Length (TileTab) - 1); + i := Tab.TabIndex; + Tab.Tabs.Delete (Tab.TabIndex); + if i <= Tab.Tabs.Count - 1 then + Tab.TabIndex := i + else + Tab.TabIndex := Tab.Tabs.Count - 1; + + if Sender <> nil then + begin + if Tab.Tabs.Count = 0 then + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + TabChange (Sender); + SetEditorMode (mTile); + end; + Modified := TRUE; + end; +end; + +procedure TMainForm.Save1Click(Sender: TObject); + var + F: File; + i, j, k, np, n: Integer; + TmpStr: string; + + procedure SaveInt (i: Integer); + begin + BlockWrite (F, i, SizeOf (i)); + end; + + procedure SaveChar (c: Char); + var + ch: {$IFDEF UNICODE} AnsiChar {$ELSE} Char {$ENDIF}; + begin + ch := {$IFDEF UNICODE} AnsiChar {$ENDIF} (c); + BlockWrite (F, ch, SizeOf (ch)); + end; + + procedure SaveString (s: string); + var + i: Integer; + begin + SaveInt (SizeOf (Integer) + Length (s)); + SaveInt (Length (s)); + for i := 1 to Length (s) do + SaveChar (s[i]); + end; + +begin + if Filename = '' then + SaveAs1Click (Sender) + else + begin +{$IFDEF CREATE_BACKUP_FILES} + if FileExists (Filename) then + begin + try + if FileExists (Filename + BACKUP_EXT) then + DeleteFile (Filename + BACKUP_EXT); + RenameFile (Filename, Filename + BACKUP_EXT); + except + if MessageDlg ('Error while creating backup file ' + + FileName + BACKUP_EXT + '. Continue?', mtError, [mbYes, mbNo], 0) = mrNo then + Exit; + end; + end; +{$ENDIF} + + ProgressPanel.Visible := TRUE; + ProgressBar.Position := 1; + ProgressBar.Min := 0; + ProgressBar.Max := Length (TileTab); + + AssignFile (F, Filename); + try + ReWrite (F, 1); + + + SaveInt (Ord ('T')); // file signature + SaveInt (Ord ('S')); + + SaveInt (Ord (VERSION_NUMBER[1]) - Ord ('0')); // version + SaveInt (Ord (VERSION_NUMBER[3]) - Ord ('0')); + + SaveInt (Ord ('I')); // 2.0 Project Information + with Info do + TmpStr := #0 + Author.Text + #0 + Notes.Text + #0 + Copyright.Text + + #0 + Chr (Byte (Startup.Checked)); + SaveString (TmpStr); + + SaveInt (Ord ('O')); // Output Path + if OutputtoProjectDirectory1.Checked then + SaveString ('') + else + SaveString (OutputPath); + + if Length (FromToSave) > 0 then + begin + SaveInt (Ord ('F')); // FromTo + SaveInt (Length (FromToSave) * SizeOf (FromToSave[0])); + for i := 0 to Length (FromToSave) - 1 do + BlockWrite (F, FromToSave[i], SizeOf (FromToSave[i])); + end; + + SaveInt (Ord ('C')); // 2.0 Config/options + TmpStr := 'S' + Chr (Ord ('0') + Byte (SmoothPalette1.Checked)) + + 'A' + Chr (aaN); + SaveString (TmpStr); + + SaveInt (Ord ('B')); // Background color + SaveInt (SizeOf (Integer)); + SaveInt (Background.Brush.Color); + + if CodeGen.LastDef <> '' then + begin + SaveInt (Ord ('D')); // Definition file + SaveString (CodeGen.LastDef); + end; + + SaveInt (Ord ('N')); // # TBRs + SaveInt (SizeOf (Integer)); + n := Length (TileTab); + SaveInt (n); + + {$IFDEF SAVETOTALTIME} + SaveInt (Ord ('Z')); + SaveInt (3 * SizeOf (Integer)); + DtTm := Now - StartTime; + SaveInt (aiDtTm[0]); + SaveInt (aiDtTm[1]); + SaveInt (Sessions); + {$ENDIF} + + SaveInt (Ord ('H')); // History + SaveString (History); + + SaveInt (Ord ('T')); // TBR data + SaveInt (0); + + for i := 0 to n - 1 do + begin + + TileTab[i].tbr.LastScale := TileTab[i].lastscale; + + + SaveTBR (F, TileTab[i].ID, TileTab[i].tbr); + + ProgressBar.Position := i + 1; + end; + + + // 2.0 + // np := Length (aaiPal); + // 2.33 + np := Length (aiPalSize); + if np > 0 then + begin + SaveInt (Ord ('P')); + + k := 0; // total palette data size + for i := 0 to np - 1 do + Inc (k, aiPalSize[i]); + j := 0; + for i := 0 to np - 1 do + Inc (j, SizeOf (Integer) + Length (PaletteManager.GetID (i))); + + SaveInt ((1 + // version + 1 + // # palettes + np + // PalSize + np + // Preset + k + // palette data + 2) // DefaultPalette, SelectedPalette + * SizeOf (Integer) + + j); // ID's + + SaveInt (1); // version + SaveInt (np); + for i := 0 to np - 1 do + SaveInt (aiPalSize[i]); + for i := 0 to np - 1 do + SaveInt (aiPreset[i]); + + for i := 0 to np - 1 do + for j := 0 to aiPalSize[i] - 1 do + SaveInt (aaiPal[i, j]); + + for i := 0 to np - 1 do + SaveString (PaletteManager.GetID (i)); + + SaveInt (DefaultPalette); + SaveInt (SelectedPalette); + end; + // + + + + SaveInt (Ord ('L')); // 3.0 Project Lists + with Lists do + SaveString (Notes.Text); + + + + + + SaveInt (0); // End + SaveInt (0); + Modified := FALSE; + except + MessageDlg ('Cannot save file ' + FileName, mtError, [mbOk], 0); + end; + CloseFile (F); + ProgressPanel.Visible := FALSE; + + AddFileToRecentProjects (FileName); + end; + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; +end; + +procedure TMainForm.SaveAs1Click(Sender: TObject); +begin + SaveDialog.Filename := Filename; + if SaveDialog.Execute then + begin + Filename := SaveDialog.Filename; + Save1Click (Sender); + end; +end; + +procedure TMainForm.Open1Click(Sender: TObject); + + var + F: File; + i, j, k, np, n: Integer; + PalVer: Integer; + Error, + Unknown: Boolean; + Cmd: Char; + Len: Integer; + Done: Boolean; + tbr: TileBitmapRec; + ID: string; + VersionHi, + VersionLo: Char; + s: string; + TmpStr: string; + ShowInfo: Boolean; + BackColor: Integer; // 3.0 + + function ReadInt: Integer; + var + i: Integer; + begin + BlockRead (F, i, SizeOf (i)); + ReadInt := i; + end; + + function ReadChar: Char; + var + c: {$IFDEF UNICODE} AnsiChar {$ELSE} Char {$ENDIF}; + begin + BlockRead (F, c, SizeOf (c)); + ReadChar := Char (c); + end; + + function ReadString: string; + var + i, L: Integer; + s: string; + begin + s := ''; + L := ReadInt; + for i := 1 to L do + s := s + ReadChar; + ReadString := s; + end; + +begin + VersionHi := '0'; + VersionLo := '0'; + + ShowInfo := FALSE; + + BackColor := -1; + + if ReadParamFile or OpenDialog.Execute then + begin + if Modified then + if not SaveChanges then + Exit; + + if ReadParamFile then + begin + Filename := FileToOpen; + if not FileExists (Filename) then + Filename := Filename + DEFAULT_EXT; + if not FileExists (Filename) then + begin + MessageDlg ('Cannot open file: ' + Filename, mtError, [mbOk], 0); + Exit; + end; + s := FileName; + if Tab.Tabs.Count > 0 then + CloseAll; + FileName := s; + end + else + begin + CloseAll; + Filename := OpenDialog.Filename; + end; + + ProgressPanel.Visible := TRUE; + ProgressBar.Min := 0; + + + Error := FALSE; + Unknown := FALSE; + AssignFile (F, Filename); + try + Reset (F, 1); + try + + VersionHi := VERSION_NUMBER[1]; + VersionLo := VERSION_NUMBER[3]; + + History := ''; + aaN := 0; { no anti-aliasing } + + if (FileSize (F) > 2 * SizeOf (Integer)) and + (ReadInt = Ord ('T')) and (ReadInt = Ord ('S')) then + begin + StartTime := Now; + DtTm := 0.0; + + ProgressBar.Position := 0; + + VersionHi := Char (ReadInt + Ord ('0')); // Version + VersionLo := Char (ReadInt + Ord ('0')); + + n := 0; + Done := FALSE; + repeat + Cmd := Chr (ReadInt); + Len := ReadInt; + + case Cmd of + #0 : Done := TRUE; + 'L': Lists.Notes.Text := ReadString; + 'I': begin + TmpStr := ReadString; + if TmpStr[1] = #0 then + with Info do + begin + Delete (TmpStr, 1, 1); + + i := Pos (#0, TmpStr); + Author.Text := Copy (TmpStr, 1, i); + Delete (TmpStr, 1, i); + i := Pos (#0, TmpStr); + Notes.Text := Copy (TmpStr, 1, i); + Delete (TmpStr, 1, i); + i := Pos (#0, TmpStr); + Copyright.Text := Copy (TmpStr, 1, i); + Delete (TmpStr, 1, i); + Startup.Checked := TmpStr <> #0; + end; + end; + 'N': begin + n := ReadInt; // # TBRs + ProgressBar.Max := n; + end; + 'T': for i := 1 to n do + begin + + if not ReadTBR (F, ID, tbr, Unknown) then + Error := TRUE; + + if Tab.Tabs.IndexOf (ID) > -1 then + ID := NewTCName; + Tab.Tabs.Add (ID); + Tab.TabIndex := Tab.Tabs.IndexOf (ID); + SetLength (TileTab, Length (TileTab) + 1); + TileTab[Tab.TabIndex].tbr := tbr; + TileTab[Tab.TabIndex].id := ID; + TileTab[Tab.TabIndex].lastscrollpos := 0; + TileTab[Tab.TabIndex].lastscale := tbr.LastScale; + if tbr.BackGr = -1 then + TileTab[Tab.TabIndex].BackGrColor := Background.Brush.Color + else + TileTab[Tab.TabIndex].BackGrColor := tbr.BackGr; + + ProgressBar.Position := i; + end; + 'F': for i := 0 to (Len div SizeOf (FromToSave[0])) - 1 do + begin + SetLength (FromToSave, i + 1); + BlockRead (F, FromToSave[i], SizeOf (FromToSave[i])); + end; + 'B': BackColor := ReadInt; + 'D': CodeGen.LastDef := ReadString; + 'C': begin + TmpStr := ReadString; + i := 1; + while i < Length (TmpStr) do + begin + case TmpStr[i] of + 'S': SmoothPalette1.Checked := TmpStr[i + 1] = '1'; + 'A': aaN := Ord (TmpStr[i + 1]); + end; + Inc (i, 2); + end; + end; + 'O': begin + OutputPath := ReadString; + SelectOutputDirectory1.Checked := OutputPath <> ''; + OutputtoProjectDirectory1.Checked := OutputPath = ''; + if OutputPath = '' then + OutputPath := FilePath (FileName); + end; + 'Z': begin + aiDtTm[0] := ReadInt; + aiDtTm[1] := ReadInt; + StartTime := Now - DtTm; + Sessions := ReadInt + 1; + end; + 'H': History := ReadString; + + // 2.0 + 'P': begin + PalVer := ReadInt; + // version 1 + np := ReadInt; + + for i := 0 to Length (aaiPal) - 1 do + SetLength (aaiPal[i], 0); + SetLength (aaiPal, np); + SetLength (aiPalSize, np); + for i := 0 to np - 1 do + begin + k := ReadInt; + aiPalSize[i] := k; + SetLength (aaiPal[i], k); + end; + SetLength (aiPreset, np); + for i := 0 to np - 1 do + aiPreset[i] := ReadInt; + + for i := 0 to np - 1 do + for j := 0 to aiPalSize[i] - 1 do + aaiPal[i, j] := ReadInt; + + for i := 0 to np - 1 do + begin + ReadInt; // skip size + PaletteManager.SetID (i, ReadString); + end; + + DefaultPalette := ReadInt; + SelectedPalette := ReadInt; + + if PalVer = 2 then + ; + end; + // + else + begin + for i := 1 to Len do + ReadChar; + Unknown := TRUE; + if not (Cmd in ['A'..'Z']) then + Error := TRUE; + end; + end; + until Done or Error; + if Done then + ShowInfo := TRUE; + end + else + Error := TRUE; + except + CloseFile (F); + MessageDlg ('File ' + Filename + ' seems to contain errors.', mtError, [mbOk], 0); + ProgressPanel.Visible := FALSE; + { CloseAll; + NewGame1Click (Sender); } + Exit; + end; + + CloseFile (F); + except + Error := TRUE; + end; + + + if Error then + begin + MessageDlg ('Cannot open file: ' + Filename, mtError, [mbOk], 0); + CloseAll; + NewGame1Click (Sender); + end + else + begin + with ProgressBar do + Position := Max; + + if Unknown then + begin + if (VersionHi > VERSION_NUMBER[1]) or + ((VersionHi = VERSION_NUMBER[1]) and + (VersionLo > VERSION_NUMBER[3])) then + MessageDlg ('The file ' + Filename + + ' was saved with a newer version of ' + + APPL_NAME + ' (version ' + + VersionHi + '.' + VersionLo + ').' + #13 + + 'Some data could not be loaded.', + mtWarning, [mbOk], 0) + else + MessageDlg (Filename + ' has an unknown format. ' + + 'Some data could not be loaded.', + mtWarning, [mbOk], 0); + end; + + if Tab.Tabs.Count = 0 then + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + Tab.TabIndex := 0; + TabChange (nil); + UpdateTileBitmap; + SetEditorMode (mTile); + + DrawUsedFromToList; + + if (BackColor <> -1) then + SetBackgroundColor (BackColor, TRUE); + + AddFileToRecentProjects (FileName); + end; + + case aaN of + 2: aa2.Click; + 3: aa3.Click; + 4: aa4.Click; + else + aaOff.Click; + end; + + ProgressPanel.Visible := FALSE; + Modified := Unknown; + +{$IFDEF SHOWTOTALTIME} + ShowMessage ('Total time: ' + Format (' %1.5f ', [DtTm]) + + ' in ' + IntToStr (Sessions) + ' session(s)'); +{$ENDIF} + + end; + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; + if ShowInfo then + if (Info.Startup.Checked) then + ProjectInformation1Click(Sender); + FitInWindow1Click (Sender); +end; + +procedure TMainForm.CloseAll; +begin + { SetEditorMode (mTile); } + ClearUndo; + while Tab.TabIndex > -1 do + RemoveTileSet1Click (nil); + SetLength (FromToSave, 0); + Modified := FALSE; + Filename := ''; + OutputPath := ''; + CodeGen.LastDef := ''; + StartTime := Now; + Sessions := 0; + + PaletteManager.ClearPalettes; + + SelectOutputDirectory1.Checked := FALSE; + OutputtoProjectDirectory1.Checked := TRUE; + + with Lists do + Notes.Text := ''; + + with Info do + begin + Author.Text := ''; + Notes.Text := ''; + Copyright.Text := ''; + Startup.Checked := FALSE; + end; + + aaOff.Click; +end; + +function TMainForm.SaveChanges: Boolean; +begin + SaveChanges := FALSE; + if Modified then + begin + case MessageDlg ('Save changes to ' + ProjectName + '?', + mtConfirmation, [mbYes, mbNo, mbCancel], 0) of + mrYes: + begin + Save1Click (nil); + if Modified then + Exit; + end; + mrCancel: + Exit; + end; + end; + SaveChanges := TRUE; +end; + +procedure TMainForm.NewGame1Click(Sender: TObject); +begin + if Modified then + if not SaveChanges then + Exit; + CloseAll; + + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + + SetEditorMode (mTile); // 2.43 bug fix: access violation + + StartEdit (TRUE); + + Filename := ''; + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; +end; + +procedure TMainForm.ToggleAnimation; +begin + if Animate1.Checked then + begin + with TileTab[Tab.TabIndex] do + begin + if AnimStart = AnimEnd then + begin + AnimStart := -1; + AnimEnd := -1; + end; + if AnimStart = -1 then + AnimStart := 0; + if (AnimEnd = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimEnd := tbr.TileCount - 1; + if AnimStart = AnimEnd then + Animate1.Checked := FALSE; + end; + end; +end; + +procedure TMainForm.Animate1Click(Sender: TObject); +begin + Animate1.Checked := not Animate1.Checked; + ToggleAnimation; + + AnimationTimer.Enabled := Animate1.Checked; + + + if Animate1.Checked then + AnimateButton.Style := tbsCheck + else + AnimateButton.Style := tbsButton; + AnimateButton.Down := Animate1.Checked; + AnimateButton.Refresh; + +end; + + + +procedure TMainForm.FirstFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + AnimStart := tbr.Current; +end; + +procedure TMainForm.LastFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + AnimEnd := tbr.Current; +end; + +procedure TMainForm.NextFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + begin + if (AnimStart = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimStart := 0; + if (AnimEnd = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimEnd := tbr.TileCount - 1; + if tbr.Current + 1 <= AnimEnd then + Inc (tbr.Current) + else + tbr.Current := AnimStart; + end; + StartEdit (FALSE); + DrawCursor; +end; + +procedure TMainForm.PreviousFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + begin + if (AnimStart = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimStart := 0; + if (AnimEnd = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimEnd := tbr.TileCount - 1; + if tbr.Current - 1 >= AnimStart then + Dec (tbr.Current) + else + tbr.Current := AnimEnd; + end; + StartEdit (FALSE); + DrawCursor; +end; + +procedure TMainForm.AnimationTimerTimer(Sender: TObject); +begin + // if AllowTimer then + begin + + if Drawing then + begin + TileMouseUp (Sender, mbLeft, ShiftState, LastX, LastY); + + NextFrame1Click (Sender); + + TileMouseDown (Sender, mbLeft, ShiftState, LastX, LastY); + end + else + NextFrame1Click (Sender); + + end; +end; + +procedure TMainForm.Default1Click(Sender: TObject); +begin + AnimationTimer.Interval := DEFAULT_ANIMATION_SPEED; +end; + +procedure TMainForm.Faster1Click(Sender: TObject); + var + i: Integer; +begin + if AnimationTimer.Enabled then + begin + i := AnimationTimer.Interval; + Dec (i, 5 + i div 10); + if i < 25 then + i := 25; + AnimationTimer.Interval := i; + end; +end; + +procedure TMainForm.Slower1Click(Sender: TObject); + var + i: Integer; +begin + if AnimationTimer.Enabled then + begin + i := AnimationTimer.Interval; + Inc (i, 5 + i div 10); + if i > 1500 then + i := 1500; + AnimationTimer.Interval := i; + end; +end; + +procedure TMainForm.TileModeButtonClick(Sender: TObject); +begin + SetEditorMode (mTile); +end; + +procedure TMainForm.MapModeButtonClick(Sender: TObject); +begin + SetEditorMode (mMap); +end; + +procedure TMainForm.ConverttoTileSequence1Click(Sender: TObject); + var + i, j, m, n: Integer; + mcr: MapCellRec; +begin + if Mode = mMap then + begin + if not Selection then + Exit; + + // check if not empty + n := 0; + m := 0; // frame lengths provided as map codes? + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if mcr.MapCode > m then + m := mcr.MapCode; + if not EmptyMCR (mcr) then + Inc (n); + end; + + if n < 1 then + Exit; + + SeqW := n; + SeqH := 1; + NewSeqMap (TileTab[Tab.TabIndex].tbr, SeqW, SeqH); + + n := SeqTab.Tabs.Count; + SeqTab.TabIndex := SeqTab.Tabs.Add (IntToStr (n)); + seq := SelectSeqMap (TileTab[Tab.TabIndex].tbr, n); + + n := 0; + with Area do + begin + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if not EmptyMCR (mcr) then + begin +// if m = 0 then +// mcr.MapCode := 25; + seq^.Map[0, n] := mcr; + Inc (n); + end; + end; + end; + + SeqTabChange (Sender); + + { RD: clear selection } + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end; +end; + +procedure TMainForm.SeqTabChange(Sender: TObject); +begin + SeqTimer.Enabled := FALSE; + + if SeqTab.TabIndex < 0 then + begin + seq := nil; + SeqBitmap.Visible := FALSE; + SeqTimer.Enabled := FALSE; + + Exit; + end; + seq := SelectSeqMap (TileTab[Tab.TabIndex].tbr, SeqTab.TabIndex); + if seq <> nil then + begin + + SeqH := Length (seq^.map); + if SeqH > 0 then + begin + SeqW := Length (seq^.map[0]); + + SeqBitmap.Width := W; + SeqBitmap.Height := H; + ResizeBitmap (SeqBitmap); + SeqBitmap.Left := (SeqTab.ClientWidth - W) div 2; + SeqBitmap.Top := 8; // (SeqTab.ClientHeight - H) div 2; + + SeqBitmap.Visible := TRUE; + + (* + { RD: draw sequence map } + DrawMap (Rect (0, 0, -1, -1), FALSE, FALSE, TRUE); + *) + + // 2.5 draw first frame right away + SeqFrame := SeqW; + SeqTimerTimer (nil); + + SeqTimer.Interval := Seq^.map[0, 0].MapCode * 10 + 1; + SeqTimer.Enabled := TRUE; + end; + end; + + Modified := TRUE; + MapTab.SetFocus; +end; + +procedure TMainForm.SeqTimerTimer(Sender: TObject); + var + mcr: MapCellRec; + OldSel: Boolean; +begin + // draw frame and set timer for next + + if SkipDraw then + begin + SeqTimer.Interval := 10; + SeqTimer.Enabled := TRUE; + end + else + begin + Inc (SeqFrame); + if SeqFrame >= SeqW then + SeqFrame := 0; + + if (Seq <> nil) + and (Length (Seq^.map) > 0) + and (Length (Seq^.map[0]) > SeqFrame) then + begin + mcr := Seq^.map[0, SeqFrame]; + + OldSel := Selection; + Selection := FALSE; + { RD: draw tile from sequence } + DrawMap (Rect (SeqFrame, 0, SeqFrame, 0), FALSE, FALSE, TRUE); + Selection := OldSel; + + SeqTimer.Interval := mcr.MapCode * 10 + 1; + SeqTimer.Enabled := TRUE; + end; + end; +end; + + +// if the BMP file header was not correctly written to disk, correct it +procedure PatchBMPFile (FileName: string); + var + F: file; + Buffer: array of Char; + Size, Diff, HS: Integer; + s: string; +begin + AssignFile (F, FileName); + Reset (F, 1); + Size := FileSize (F); + SetLength (Buffer, Size); + BlockRead (F, Buffer[0], Size); + CloseFile (F); + + HS := StrInt (Buffer[2] + Buffer[3] + Buffer[4] + Buffer[5]); + if HS <> Size then + if MessageDlg ('The BMP file has not been saved correctly. Correct header?', + mtWarning, [mbYes, mbNo], 0) = mrYes then + begin + if HS > Size then + ShowMessage ('Cannot correct header') + else + begin + Diff := Size - HS; + s := IntStr (Size); + Buffer[2] := s[1]; + Buffer[3] := s[2]; + Buffer[4] := s[3]; + Buffer[5] := s[4]; + s := IntStr (StrInt (Buffer[10] + Buffer[11] + Buffer[12] + Buffer[13]) + Diff); + Buffer[10] := s[1]; + Buffer[11] := s[2]; + Buffer[12] := s[3]; + Buffer[13] := s[4]; + DeleteFile (FileName); + AssignFile (F, FileName); + ReWrite (F, 1); + BlockWrite (F, Buffer[0], Size); + CloseFile (F); + end; + end; + + SetLength (Buffer, 0); +end; + + +procedure TMainForm.RemoveTileSequence1Click(Sender: TObject); + var + i, j: Integer; +begin + if SeqTab.TabIndex > -1 then + begin + RemoveSeq (TileTab[Tab.TabIndex].tbr, SeqTab.TabIndex); + Modified := TRUE; + with SeqTab do + begin + j := TabIndex; + Tabs.Delete (TabIndex); + for i := j to Tabs.Count - 1 do + Tabs.Strings[i] := IntToStr (StrToInt (Tabs.Strings[i]) - 1); + if j <= Tabs.Count - 1 then + TabIndex := j + else + TabIndex := Tabs.Count - 1; + end; + SeqTabChange (Sender); + UpdateMapRegion (Rect(0, 0, -1, -1)); + Modified := TRUE; + end +end; + +procedure TMainForm.InsertTileSequence1Click(Sender: TObject); + var + i, j: Integer; +begin + if (Mode = mMap) and Selection and (SeqTab.TabIndex > -1) then + begin + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + with lmp^.Map[j, i] do + begin + Back := -1; + Mid := -1; + Front := -1; + MapCode := SeqTab.TabIndex; + // Bounds := $FF; + // Bounds := ShortInt (Bounds or $80); + Bounds := ShortInt (Bounds or $40); // 2.55 + end; + end; + Modified := TRUE; + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end; + end; +end; + +procedure TMainForm.PreviousPattern1Click(Sender: TObject); +begin + if FromToSavePos > 0 then + Dec (FromToSavePos) + else + FromToSavePos := Length (FromToSave) - 1; + if FromToSavePos >= 0 then + SelectSavedFromToList; +end; + +procedure TMainForm.NextPattern1Click(Sender: TObject); +begin + if FromToSavePos < Length (FromToSave) - 1 then + Inc (FromToSavePos) + else + FromToSavePos := 0; + SelectSavedFromToList; +end; + +procedure TMainForm.SelectSavedFromToList; +{ var + i, R, G, B: Integer; } +begin + if FromToSavePos < Length (FromToSave) then + with FromToSave[FromToSavePos] do + begin + FromToList := FT; + ExFromToList := EXFT; + { + for i := 0 to MAX_FROM_TO - 1 do + begin + R := LimitRGB (EXFT[i, 0]); + G := LimitRGB (EXFT[i, 1]); + B := LimitRGB (EXFT[i, 2]); + FromToList[i] := RGB (R, G, B); + end; + } + FromToFirst := F; + FromToLast := L; + FromTo.Repaint; + end; +end; + +function TMainForm.FindCurrentColorPattern (FindColor: Integer; All: Boolean): Integer; + var + i, j, k, diff: Integer; + FTF, FTL: Integer; +begin + for k := Length (FromToSave) - 1 downto 0 do + with FromToSave[k] do + begin + FindCurrentColorPattern := k; + + if (FindColor <> -1) then // 2.53 + begin + FTF := FromToSave[k].F; + FTL := FromToSave[k].L; + if All then + begin + FTF := 0; + FTL := MAX_FROM_TO - 1; + end; + for i := FTF to FTL do + if FT[i] = FindColor then + begin + if (not (ssAlt in LastShift)) then + begin + FromToFirst := i; + FromToLast := i; + end; + Exit; + end; + end + else + begin + diff := byte ((FromToSave[k].F <> FromToFirst) or + (FromToSave[k].L <> FromToLast)); + for i := 0 to MAX_FROM_TO - 1 do + for j := 0 to 2 do + if EXFT[i, j] <> ExFromToList[i, j] then + Inc (diff); + if diff = 0 then + Exit; + end; + end; + FindCurrentColorPattern := -1; +end; + +procedure TMainForm.FindPatternForColor; +begin + +end; + +procedure TMainForm.AddColorPattern1Click(Sender: TObject); +begin + if FindCurrentColorPattern (-1, FALSE) > -1 then + Exit; + SetLength (FromToSave, Length (FromToSave) + 1); + FromToSavePos := Length (FromToSave) - 1; + with FromToSave[FromToSavePos] do + begin + FT := FromToList; + EXFT := ExFromToList; + F := FromToFirst; + L := FromToLast; + end; + DrawUsedFromToList; + Modified := TRUE; +end; + +procedure TMainForm.DrawUsedFromToList; + var + bmp: TBitmap; + x, y: Integer; +begin + bmp := TBitmap.Create; + SetStretchBltMode(bmp.Canvas.Handle, HALFTONE); + with bmp do + begin + PixelFormat := pf24bit; + width := MAX_FROM_TO; + height := Length (FromToSave); + + for y := 0 to height - 1 do + for x := 0 to MAX_FROM_TO - 1 do + begin + Canvas.Pixels[x, y] := ColorPatternsPanel.Color; + if FromToSave[y].F < FromToSave[y].L then + begin + if (x >= FromToSave[y].F) and (x <= FromToSave[y].L) then + Canvas.Pixels[x, y] := FromToSave[y].FT[x]; + end + else + if (x >= FromToSave[y].L) and (x <= FromToSave[y].F) then + Canvas.Pixels[x, y] := FromToSave[y].FT[MAX_FROM_TO - 1 - x]; + end; + + ColorPatternsImage.Picture.Bitmap := bmp; + ColorPatternsImage.Stretch := TRUE; + bmp.Free; + end; +end; + +procedure TMainForm.RemoveColorPattern1Click(Sender: TObject); + var + i: Integer; +begin + i := FindCurrentColorPattern (-1, FALSE); + if i = -1 then + Exit + else + FromToSavePos := i; + if FromToSavePos < Length (FromToSave) then + begin + for i := FromToSavePos + 1 to Length (FromToSave) - 1 do + FromToSave[i - 1] := FromToSave[i]; + SetLength (FromToSave, Length (FromToSave) - 1); + if FromToSavePos >= Length (FromToSave) then + FromToSavePos := 0; + SelectSavedFromToList; + end; + Modified := TRUE; +end; + + + + var + itab, imap, itile, itstile, { itinytile, } idat, + iseq, iseqdat, ipal, ipaldat: Integer; + itilemap, icorner, icornerdat, // 2.4 + itmpdat, + ihedge, ihedgedat, + ivedge, ivedgedat, + itile0: Integer; + + iutt: Integer; // 2.5 + + itb: Integer; // 2.54 + + ifile: Integer; // 3.00 (input file text line / bin pos) + + +procedure TMainForm.Generate1Click(Sender: TObject); + + type + TVarType = (vtNum, vtStr); + TVarRec = + record + Name: string; + case vt: TVarType of + vtNum: (Num: Integer); + vtStr: (Str: string[255]); // 2.0 + end; + + const + ExprChars = [' ', '+', '-', '*', '/', '(', ')', '&', '|', '%', '!']; + + // 2.4 + const + EdgesX: array[0..7] of Integer = (-1, 0, 1, -1, 1, -1, 0, 1); + EdgesY: array[0..7] of Integer = (-1, -1, -1, 0, 0, 1, 1, 1); + EdgeToCorner: array[0..7] of Integer = (3, -1, 2, -1, -1, 1, -1, 0); + CornerToEdge: array[0..3] of Integer = (0, 2, 5, 7); + + var + EdgeSrc: array[0..7] of TRect; + EdgeDst: array[0..7] of TRect; + TileCornerX: array[0..3] of Integer; + TileCornerY: array[0..3] of Integer; + TmpCorner: array[0..3] of Integer; + + type + CornerRec = + record + Tiles: array[0..3] of Integer; + Count: Integer; + Colors: array[0..3] of Integer; + Number: Integer; + Used: Boolean; + end; + + EdgeRec = + record + Tiles: array[0..1] of Integer; + Count: Integer; + end; + + var + Corners: array of array of CornerRec; + HEdges: array of array of EdgeRec; + VEdges: array of array of EdgeRec; + + type + FlipType = (NOFLIP, HFLIP, VFLIP, HVFLIP); + FlipInts = array[FlipType] of Integer; + + var + ValidTileSet: Boolean; + ValidTSTileSet: Boolean; // 3.0 + + VarList: array of TVarRec; + + aMCR: array of array of MapCellRec; + aFinalRef: array of array of Integer; + bmpFinal: array of TBitmap; + bmpAlpha: array of TBitmap; // 2.5 + aFinalTileCount: array of Integer; + bmpCurTile: TBitmap; // 2.54 + CurRGB: Integer; + DataW, DataH: Integer; + + // 2.4 + TexTiles: Boolean; + bmpTexTiles: array of TBitmap; + bmpTexAlpha: array of TBitmap; // 2.5 + aMCRSur: array of array of array[0..7] of array of Integer; + aSameAs: array of array of array[0..7] of Integer; + aTrans: array of array of array[0..7] of Integer; + aCornerCount: array of Integer; + aHEdgeCount: array of Integer; + aVEdgeCount: array of Integer; + + // 2.5 - UniuqeTexTiles + UTT: Boolean; + aUTTRef: array of array of array of array[0..8] of Integer; + aUTTIndex: array of array of Integer; + aUTTCount: array of Integer; + aTransTile: array of Integer; + + // 2.2 + TinyTiles: Boolean; + aFinalTinyTileCount: array of FlipInts; + aFinalTinyTiles: array of array[FlipType] of array of Integer; + aFinalTinyRef: array of array of FlipInts; + TinyW, TinyH: Integer; + TinyNH, TinyNV: Integer; + TinyFlip: FlipType; + + code: string; + Error: Boolean; + MapWd, MapHt, tmpW, tmpH: Integer; + SeqLen: Integer; + // crc: string; + TransX, TransY: array of Integer; + NumericExpr: Boolean; // all variables used are numbers? + TransReplace: string; // 2.0 + Quote: Boolean; // 2.1 + + // 2.5 + aa: Boolean; + aaX, aaY: Integer; + + // 3.0 + SeqFrames: Integer; + + // options + StartWithEmptyTile: Boolean; + + + + const + MAX_COUNTER = 100; + + var + Counters: array[0..MAX_COUNTER] of LongInt; + ReadingAhead: Boolean; + + + + function GetTinyNH: Integer; + begin + if TinyTiles then + GetTinyNH := TinyNH + else + GetTinyNH := 1; + end; + + function GetTinyNV: Integer; + begin + if TinyTiles then + GetTinyNV := TinyNV + else + GetTinyNV := 1; + end; + + + procedure SetNumVar (ID: string; Value: Integer); + var + i: Integer; + begin + ID := UpCaseStr (ID); + for i := 0 to Length (VarList) - 1 do + if VarList[i].Name = ID then + begin + VarList[i].vt := vtNum; + VarList[i].Num := Value; + Exit; + end; + SetLength (VarList, Length (VarList) + 1); + i := Length (VarList) - 1; + VarList[i].Name := ID; + VarList[i].vt := vtNum; + VarList[i].Num := Value; + end; + + procedure SetStrVar (ID: string; Value: string); + var + i: Integer; + begin + ID := UpCaseStr (ID); + for i := 0 to Length (VarList) - 1 do + if VarList[i].Name = ID then + begin + VarList[i].vt := vtStr; + VarList[i].Str := Value; + Exit; + end; + SetLength (VarList, Length (VarList) + 1); + i := Length (VarList) - 1; + VarList[i].Name := ID; + VarList[i].vt := vtStr; + VarList[i].Str := Value; + end; + + function AddLeadingZeros (s, Fmt: string): string; + var + p: Integer; + begin + p := Pos ('%0', Fmt); + if p > 0 then + while (p < Length (s)) and (s[p] = ' ') do + begin + s[p] := '0'; + Inc (p); + end; + AddLeadingZeros := s; + end; + + function GetVarValue (ID, Fmt: string): string; + var + i: Integer; + s: string; + N: LongInt; + begin + s := UpCaseStr (ID); + for i := 0 to Length (VarList) - 1 do + if VarList[i].Name = s then + case VarList[i].vt of + vtStr: + begin + // if (s <> 'SHR') and (s <> 'SHL') then + if (Pos (' ' + s + ' ', ' SHR SHL IF THEN ELSE NOT EQUALS ABOVE BELOW ') <= 0) then + NumericExpr := FALSE; + GetVarValue := VarList[i].Str; + Exit; + end; + vtNum: + begin + s := Format (Fmt, [VarList[i].Num]); + GetVarValue := AddLeadingZeros (s, Fmt); + Exit; + end; + end; + + if (Copy (s, 1, 7) = 'COUNTER') and (Length (s) > 7) then // 3.0 + begin + Delete (s, 1, 7); + Val (s, N, i); + if (i = 0) and (N <= MAX_COUNTER) then + begin + i := N; + N := Counters[i]; + s := Format (Fmt, [N]); + if not ReadingAhead then + Inc (Counters[i]); + GetVarValue := AddLeadingZeros (s, Fmt); + Exit; + end; + end; + + { + MessageDlg ('Error in code generation definition: uninitialized variable (' + + ID + ').', mtError, [mbOk], 0); + } + Error := TRUE; + GetVarValue := ''; + end; + + + + + + procedure GetTinyPos (itab, p: Integer; var x, y: Integer); + var + NH: Integer; + TileNo, TileX, TileY: Integer; + begin + if p = -1 then // transparant + begin + x := -1; + y := -1; + end + else + with TileTab[itab] do + begin + NH := bmpFinal[itab].Width div tbr.W; + TileNo := p div (TinyNH * TinyNV); + p := p mod (TinyNH * TinyNV); + TileX := TileNo mod NH; + TileY := TileNo div NH; + x := TileX * tbr.W + (p mod TinyNH) * TinyW; + y := TileY * tbr.H + (p div TinyNH) * TinyH; + end; + end; + + // 2.2 + procedure SetupTinyTiles (W, H: Integer; F: FlipType); + var + itab: Integer; + + const + EmptyFlipInt: FlipInts = (0, 0, 0, 0); + + + function FindTinyTile (P: Integer; F: FlipType): Integer; + var + n: Integer; + PX, PY: Integer; + x, y, i, j: Integer; + Diff: Boolean; + Found: Integer; + begin + Found := -1; + if P <> -1 then + with TileTab[itab] do + begin + GetTinyPos (itab, P, PX, PY); + for n := 0 to aFinalTinyTileCount[itab][F] - 1 do + if Found = -1 then + begin + GetTinyPos (itab, aFinalTinyTiles[itab][TinyFlip][n], + x, y); + + Diff := FALSE; + for j := 0 to TinyH - 1 do + for i := 0 to TinyW - 1 do + if not Diff then + if (x = -1) or (y = -1) then + begin + if (bmpFinal[itab].Canvas.Pixels[PX + i, PY + j]) <> TRANS_COLOR then + Diff := TRUE; + end + else + begin + if (bmpFinal[itab].Canvas.Pixels[PX + i, PY + j]) <> + (bmpFinal[itab].Canvas.Pixels[x + i, y + j]) then + Diff := TRUE; + end; + + if not Diff then + Found := n; // aFinalTinyTiles[itab][TinyFlip][n]; + end; + end; + FindTinyTile := Found; + end; + + function AddTinyTile (i: Integer; F: FlipType): Integer; + var + n, l: Integer; + begin + n := FindTinyTile (i, F); + if (n = -1) then + begin + l := aFinalTinyTileCount[itab][F]; + Inc (aFinalTinyTileCount[itab][F]); + SetLength (aFinalTinyTiles[itab][F], l + 1); + aFinalTinyTiles[itab][F][l] := i; + n := l; + end; + AddTinyTile := n; + end; + + var + i: Integer; + + begin { SetupTinyTiles } + TinyFlip := F; + if (W = TinyW) and (H = TinyH) then + Exit; + + TinyW := W; + TinyH := H; + + for itab := 0 to Tab.Tabs.Count - 1 do + begin + SetLength (aFinalTinyTiles[itab][NOFLIP], 0); + SetLength (aFinalTinyTiles[itab][HFLIP], 0); + SetLength (aFinalTinyTiles[itab][VFLIP], 0); + SetLength (aFinalTinyTiles[itab][HVFLIP], 0); + + SetLength (aFinalTinyRef[itab], 0); + end; + + for itab := 0 to Tab.Tabs.Count - 1 do + with TileTab[itab] do + begin + aFinalTinyTileCount[itab] := EmptyFlipInt; + if (W > 0) and (tbr.W mod W = 0) and + (H > 0) and (tbr.H mod H = 0) then + begin + TinyNH := tbr.W div W; + TinyNV := tbr.H div H; + + SetLength (aFinalTinyRef[itab], + aFinalTileCount[itab] * TinyNH * TinyNV); + + AddTinyTile (-1, NOFLIP); // add empty tile + for i := 0 to aFinalTileCount[itab] * TinyNH * TinyNV - 1 do + aFinalTinyRef[itab][i][TinyFlip] := AddTinyTile (i, NOFLIP); + end; + end; + end; + + + procedure ShowProgress (Pos, Max: Integer); + begin + ProgressBar.Position := 100 * itab + Pos * 100 div Max; + end; + + function FindMCR (const mcr: MapCellRec): Integer; // -1: not found + var + i: Integer; + begin + for i := 0 to Length (aMCR[itab]) - 1 do + if (aMCR[itab][i].Back = mcr.Back) and + (aMCR[itab][i].Mid = mcr.Mid) and + (aMCR[itab][i].Front = mcr.Front) then + begin + FindMCR := i; + Exit; + end; + FindMCR := -1; + end; + + procedure AddMCR (const mcr: MapCellRec); + var + i: Integer; + Found: Boolean; + begin + i := FindMCR (mcr); + // Found := (i > -1) or (mcr.Bounds = $FF); // skip sequence + Found := (i > -1) or (mcr.Bounds and $40 <> 0); // skip sequence + if not Found then + begin + i := Length (aMCR[itab]); + SetLength (aMCR[itab], i + 1); + aMCR[itab][i] := mcr; + end; + end; + + procedure AddMCRs (const aaMaps: aaMapCellRec); + var + i, j: Integer; + begin + for j := 0 to Length (aaMaps) - 1 do + for i := 0 to Length (aaMaps[j]) - 1 do + AddMCR (aaMaps[j, i]); + end; + + + + procedure AddEdge (Edge: Integer; const mcr, mcr2: MapCellRec); + var + i, j, k, l: Integer; + Found: Boolean; + begin + j := FindMCR (mcr); + if j > -1 then + begin + j := aFinalRef[itab][j]; + + k := FindMCR (mcr2); + if k > -1 then + k := aFinalRef[itab][k]; + + Found := FALSE; + l := Length (aMCRSur[itab][j][Edge]); + for i := 0 to l - 1 do + if i mod 2 = 0 then + if aMCRSur[itab][j][Edge][i] = k then + begin + Inc (aMCRSur[itab][j][Edge][i + 1]); + Found := TRUE; + end; + if not Found then + begin + SetLength (aMCRSur[itab][j][Edge], l + 2); + aMCRSur[itab][j][Edge][l] := k; + aMCRSur[itab][j][Edge][l + 1] := 1; + end; + + end; + end; + + + procedure AddAllEdges (Edge: Integer; const mcr, mcr2: MapCellRec; const Seq: MapSet); + var + i, j: Integer; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + // if mcr2.Bounds <> $FF then + if mcr2.Bounds and $40 = 0 then + AddEdge (Edge, mcr, mcr2) + else + for i := 0 to Length (Seq.aMaps[mcr2.MapCode].Map[0]) - 1 do + AddEdge (Edge, mcr, Seq.aMaps[mcr2.MapCode].Map[0, i]) + else + // if mcr2.Bounds <> $FF then + if mcr2.Bounds and $40 = 0 then + for j := 0 to Length (Seq.aMaps[mcr.MapCode].Map[0]) - 1 do + AddEdge (Edge, Seq.aMaps[mcr.MapCode].Map[0, j], mcr2) + else + if mcr.MapCode = mcr2.MapCode then // 2.43 + begin + for i := 0 to Length (Seq.aMaps[mcr.MapCode].Map[0]) - 1 do + AddEdge (Edge, Seq.aMaps[mcr.MapCode].Map[0, i], + Seq.aMaps[mcr2.MapCode].Map[0, i]); + end + else + for j := 0 to Length (Seq.aMaps[mcr.MapCode].Map[0]) - 1 do + for i := 0 to Length (Seq.aMaps[mcr2.MapCode].Map[0]) - 1 do + AddEdge (Edge, Seq.aMaps[mcr.MapCode].Map[0, j], + Seq.aMaps[mcr2.MapCode].Map[0, i]) + end; + + + procedure AddCorner (const mcr0, mcr1, mcr2, mcr3: MapCellRec); + var + CR: CornerRec; + i, j, L: Integer; + begin + CR.Tiles[0] := FindMCR (mcr0); + CR.Tiles[1] := FindMCR (mcr1); + CR.Tiles[2] := FindMCR (mcr2); + CR.Tiles[3] := FindMCR (mcr3); + + j := -1; + L := Length (Corners[itab]); + for i := 0 to L - 1 do + with Corners[itab][i] do + if (CR.Tiles[0] = Tiles[0]) and + (CR.Tiles[1] = Tiles[1]) and + (CR.Tiles[2] = Tiles[2]) and + (CR.Tiles[3] = Tiles[3]) then + j := i; + + if j <> -1 then + Inc (Corners[itab][j].Count) + else + begin + CR.Count := 1; + CR.Used := FALSE; + SetLength (Corners[itab], L + 1); + Corners[itab][L] := CR; + end; + end; + + + procedure AddAllCorners (const mcr0, mcr1, mcr2, mcr3: MapCellRec; const Seq: MapSet); + + function GetCount (const mcr: MapCellRec): Integer; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := 1 + else + Result := Length (Seq.aMaps[mcr.MapCode].Map[0]); + end; + + function GetMCR (const mcr: MapCellRec; N: Integer): MapCellRec; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := mcr + else + Result := Seq.aMaps[mcr.MapCode].Map[0][N]; + end; + + + var + i, j, k, l: Integer; + begin + for i := 0 to GetCount (mcr0) - 1 do + for j := 0 to GetCount (mcr1) - 1 do + for k := 0 to GetCount (mcr2) - 1 do + for l := 0 to GetCount (mcr3) - 1 do + AddCorner (GetMCR (mcr0, i), + GetMCR (mcr1, j), + GetMCR (mcr2, k), + GetMCR (mcr3, l)); + end; + + + procedure CreateEdgeData (const aaMaps: aaMapCellRec; const Seq: MapSet); + var + W, H, X, Y: Integer; + i, j, edge: Integer; + begin + H := Length (aaMaps); + for j := 0 to H - 1 do + begin + W := Length (aaMaps[j]); + for i := 0 to W - 1 do + begin + + for edge := 0 to 7 do + if EdgeToCorner[edge] = -1 then + begin + X := (i + EdgesX[edge] + W) mod W; + Y := (j + EdgesY[edge] + H) mod H; + AddAllEdges (edge, aaMaps[j, i], aaMaps[Y, X], Seq); + end; + + X := (i + 1) mod W; + Y := (j + 1) mod H; + AddAllCorners (aaMaps[j, i], aaMaps[j, X], aaMaps[Y, i], aaMaps[Y, X], Seq); + + end; + end; + end; + + + + function GetTransCount (tile, edge: Integer): Integer; + var + i, j, k: Integer; + Y: Integer; + begin + k := 0; + with TileTab[itab].tbr do + Y := (tile - 1) * (H + 2); + with bmpTexTiles[itab].Canvas do + with EdgeSrc[edge] do + for j := top to bottom - 1 do + for i := left to right - 1 do + if (Y < 0) or (Pixels[i, Y + j] = TRANS_COLOR) then + Inc (k); + Result := k; + end; + + + function CompareEdge (tile1, tile2, edge: Integer): Boolean; + var + i, j: Integer; + Y1, Y2: Integer; + begin + Result := FALSE; + with TileTab[itab].tbr do + begin + Y1 := (tile1 - 1) * (H + 2); + Y2 := (tile2 - 1) * (H + 2); + end; + with bmpTexTiles[itab].Canvas do + with EdgeSrc[7 - edge] do + for j := top to bottom - 1 do + for i := left to right - 1 do + if Pixels[i, Y1 + j] <> Pixels[i, Y2 + j] then + Exit; + + Result := TRUE; + end; + + + procedure FindSameEdges; + var + i, tile, edge, N: Integer; + begin + for tile := 0 to Length (aMCRSur[itab]) - 1 do + for edge := 0 to 7 do + aTrans[itab][tile][edge] := GetTransCount (tile, edge); + + for edge := 0 to 7 do + if EdgeToCorner[edge] = -1 then + begin + N := Length (aMCRSur[itab]); + for tile := 0 to N - 1 do + begin + i := tile - 1; + while (i >= 0) and (not CompareEdge (i, tile, edge)) do + Dec (i); + aSameAs[itab][tile][edge] := i; + end; + end; + end; + + + + // 2.5 + + function CompareAllEdges (tile: Integer; sur1, sur2: Integer): Boolean; + var + t1, t2: Integer; + edge: Integer; + i: Integer; + + begin + Result := FALSE; + for edge := 0 to 7 do + begin + t1 := aUTTRef[itab][tile][sur1][edge]; + t2 := aUTTRef[itab][tile][sur2][edge]; + + if t1 <> t2 then + if EdgeToCorner[edge] = -1 then + begin + if not CompareEdge (t1, t2, edge) then + Exit; + end + else + begin + for i := 0 to 3 do + if Corners[itab][t1].Colors[i] <> Corners[itab][t2].Colors[i] then + Exit; + end; + end; + + Result := TRUE; + end; + + + function FindCorner (t0, t1, t2, t3: Integer): Integer; + var + i: Integer; + begin + Result := -1; + + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if (t0 = Tiles[0]) and + (t1 = Tiles[1]) and + (t2 = Tiles[2]) and + (t3 = Tiles[3]) then + Result := i; + end; + + + function AddTileCombination (tile: Integer; surtiles: array of Integer): SmallInt; + var + i, j, l, t: Integer; + Same, Found: Boolean; + begin + Result := tile; + if tile <= 0 then + Exit; + + { ((0, 1, 0, 1, 1, 0, 1, 1, 3), (0, 1, 0, 1, 1, 1, 2, 2, 4), (0, 1, 0, 1, 1, 2, 1, 0, 5), + (0, 1, 1, 1, 2, 0, 1, 3, 6), (2, 1, 0, 2, 1, 4, 1, 0, 7), + (0, 1, 3, 1, 1, 0, 1, 0, 8), (3, 2, 4, 1, 1, 0, 1, 0, 9), (4, 1, 0, 1, 1, 0, 1, 0, 10)) } + + surtiles[0] := FindCorner (surtiles[0], surtiles[1], surtiles[3], tile); + surtiles[2] := FindCorner (surtiles[1], surtiles[2], tile, surtiles[4]); + surtiles[5] := FindCorner (surtiles[3], tile, surtiles[5], surtiles[6]); + surtiles[7] := FindCorner (tile, surtiles[4], surtiles[6], surtiles[7]); + + for i := 0 to Length (aUTTRef[itab][tile]) - 1 do + begin + Same := TRUE; + for j := 0 to 7 do + if surtiles[j] <> aUTTRef[itab][tile][i][j] then + Same := FALSE; + if Same then + begin + Result := aUTTRef[itab][tile][i][8]; + Exit; + end; + end; + + Found := FALSE; + for j := 0 to 7 do + begin + l := Length (aMCRSur[itab][tile][j]); + for i := 0 to l - 1 do + if i mod 2 = 0 then + begin + t := aMCRSur[itab][tile][j][i]; + { if EdgeToCorner[j] <> -1 then + t := corners[itab][t].Tiles[3 - EdgeToCorner[j]]; } + + if t = surtiles[j] then + Found := TRUE; + end; + end; + if not Found then + Exit; + + l := Length (aUTTRef[itab][tile]); + SetLength (aUTTRef[itab][tile], l + 1); + for j := 0 to 7 do + aUTTRef[itab][tile][l][j] := surtiles[j]; + + Found := FALSE; + for i := 0 to l - 1 do + if not Found then + if CompareAllEdges (tile, i, l) then + begin + t := aUTTRef[itab][tile][i][8]; + aUTTRef[itab][tile][l][8] := t; + Result := t; + Found := TRUE; + end; + if not Found then + begin + i := aUTTCount[itab]; + aUTTRef[itab][tile][l][8] := i + 1; + SetLength (aUTTIndex[itab], i + 1); + + aUTTIndex[itab][i] := tile; + Inc (aUTTCount[itab]); + Result := i + 1; + end; + end; + + + procedure CreateUTTData (const aaMaps: aaMapCellRec; const Seq: MapSet); + var + W, H, X, Y: Integer; + i, j, edge: Integer; + aMCR: array[0..7] of MapCellRec; + + function AddAllCombinations (mcr: MapCellRec): SmallInt; + + function GetCount (const mcr: MapCellRec): Integer; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := 1 + else + Result := Length (Seq.aMaps[mcr.MapCode].Map[0]); + end; + + function GetMCR (const mcr: MapCellRec; N: Integer): MapCellRec; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := mcr + else + Result := Seq.aMaps[mcr.MapCode].Map[0][N]; + end; + + var + i, j, k, l, m, n, o, p, q: Integer; + a: Integer; + ai: array[0..7] of Integer; + begin + Result := -1; + for i := 0 to GetCount (aMCR[0]) - 1 do + begin + ai[0] := FindMCR (GetMCR (aMCR[0], i)); + for j := 0 to GetCount (aMCR[1]) - 1 do + begin + ai[1] := FindMCR (GetMCR (aMCR[1], j)); + for k := 0 to GetCount (aMCR[2]) - 1 do + begin + ai[2] := FindMCR (GetMCR (aMCR[2], k)); + for l := 0 to GetCount (aMCR[3]) - 1 do + begin + ai[3] := FindMCR (GetMCR (aMCR[3], l)); + for m := 0 to GetCount (mcr) - 1 do + begin + a := FindMCR (GetMCR (mcr, m)); + for n := 0 to GetCount (aMCR[4]) - 1 do + begin + ai[4] := FindMCR (GetMCR (aMCR[4], n)); + for o := 0 to GetCount (aMCR[5]) - 1 do + begin + ai[5] := FindMCR (GetMCR (aMCR[5], o)); + for p := 0 to GetCount (aMCR[6]) - 1 do + begin + ai[6] := FindMCR (GetMCR (aMCR[6], p)); + for q := 0 to GetCount (aMCR[7]) - 1 do + begin + ai[7] := FindMCR (GetMCR (aMCR[7], q)); + Result := AddTileCombination (a, ai); + end; + end; + end; + end; + end; + end; + end; + end; + end; + end; + + begin + H := Length (aaMaps); + for j := 0 to H - 1 do + begin + W := Length (aaMaps[j]); + for i := 0 to W - 1 do + begin + + for edge := 0 to 7 do + begin + X := (i + EdgesX[edge] + W) mod W; + Y := (j + EdgesY[edge] + H) mod H; + aMCR[edge] := aaMaps[Y, X]; + end; + + aaMaps[j, i].Tag := AddAllCombinations (aaMaps[j, i]); + end; + end; + end; + + + + procedure SetEdgeRects (W, H: Integer); + begin + EdgeSrc[0] := MakeRect (W, H, 1, 1); + EdgeSrc[1] := MakeRect (1, H, W, 1); + EdgeSrc[2] := MakeRect (1, H, 1, 1); + EdgeSrc[3] := MakeRect (W, 1, 1, H); + EdgeSrc[4] := MakeRect (1, 1, 1, H); + EdgeSrc[5] := MakeRect (W, 1, 1, 1); + EdgeSrc[6] := MakeRect (1, 1, W, 1); + EdgeSrc[7] := MakeRect (1, 1, 1, 1); + + EdgeDst[0] := MakeRect (0, 0, 1, 1); + EdgeDst[1] := MakeRect (1, 0, W, 1); + EdgeDst[2] := MakeRect (W + 1, 0, 1, 1); + EdgeDst[3] := MakeRect (0, 1, 1, H); + EdgeDst[4] := MakeRect (W + 1, 1, 1, H); + EdgeDst[5] := MakeRect (0, H + 1, 1, 1); + EdgeDst[6] := MakeRect (1, H + 1, W, 1); + EdgeDst[7] := MakeRect (W + 1, H + 1, 1, 1); + + TileCornerX[0] := 0; + TileCornerY[0] := 0; + TileCornerX[1] := W; + TileCornerY[1] := 0; + TileCornerX[2] := 0; + TileCornerY[2] := H; + TileCornerX[3] := W; + TileCornerY[3] := H; + end; + + + procedure GetEdgeColors; + var + i, j, k, x, y: Integer; + begin + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + begin + + for j := 0 to 3 do + begin + with EdgeSrc[CornerToEdge[j]] do + begin + x := Left; + y := Top; + end; + + with TileTab[itab].tbr do + begin + k := (Tiles[j] - 1) * (H + 2); + if k < 0 then + Colors[j] := TRANS_COLOR + else + Colors[j] := bmpTexTiles[itab].Canvas.Pixels[x, y + k]; + end; + end; + + end; + end; + + + function GetBestCorner (tile, corner: Integer; ai: array of Integer): Integer; + var + i, j, N, Total: Integer; + othercorner: Integer; + Diff: Boolean; + begin + N := -1; + othercorner := 3 - corner; + Total := -1; + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if tile = Tiles[corner] then + begin + Diff := FALSE; + for j := 0 to 3 do + if j <> othercorner then + if Colors[j] <> ai[j] then + Diff := TRUE; + if not Diff then + begin + if Count > Total then + begin + N := i; + Total := Count; + end; + end; + end; + + Result := N; + end; + + + function NumberCornerData: Integer; + + function Cmp (N1, N2: Integer): Boolean; + var + i: Integer; + begin + Cmp := TRUE; + for i := 0 to 3 do + if (Corners[itab][N1].Tiles[i] < Corners[itab][N2].Tiles[i]) then + begin + Cmp := FALSE; + Exit; + end + else + if (Corners[itab][N1].Tiles[i] > Corners[itab][N2].Tiles[i]) then + begin + Cmp := TRUE; + Exit; + end; + end; + + var + i, j, k: Integer; + N: Integer; + ai: array of Integer; + begin + N := 0; + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if Used then + begin + Inc (N); + SetLength (ai, N); + ai[N - 1] := i; + end + else + Number := -1; + + for i := 0 to N - 1 do + for j := i + 1 to N - 1 do + if Cmp (ai[i], ai[j]) then + begin + k := ai[i]; + ai[i] := ai[j]; + ai[j] := k; + end; + + for i := 0 to N - 1 do + Corners[itab][ai[i]].Number := i; + + SetLength (ai, 0); + + Result := N; + end; + + + procedure CreateCornerData (tile, edge, N: Integer; ai: array of Integer); + var + i, j, k, l, tc: Integer; + corner: Integer; + Found: Boolean; + Diff: Boolean; + begin + corner := EdgeToCorner[edge]; + + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if Tiles[corner] = tile then + begin + TC := 0; + Diff := FALSE; + for j := 0 to 3 do + begin + if Colors[j] <> ai[j] then + Diff := TRUE; + if Colors[j] = TRANS_COLOR then + Inc (TC); + end; + + if (TC < 4) and Diff then + begin + Found := FALSE; + k := i; + l := Length (aMCRSur[itab][tile][edge]); + for j := 0 to l - 1 do + if j mod 2 = 0 then + if aMCRSur[itab][tile][edge][j] = k then + begin + Inc (aMCRSur[itab][tile][edge][j + 1], Count); + Found := TRUE; + end; + if not Found then + begin + SetLength (aMCRSur[itab][tile][edge], l + 2); + aMCRSur[itab][tile][edge][l] := k; + aMCRSur[itab][tile][edge][l + 1] := Count; + end; + Used := TRUE; + end; + end; + end; + + + procedure CreateHVEdgeData; + + procedure AddHEdge (tile1, tile2, Cnt: Integer); + var + i, L: Integer; + begin + L := Length (HEdges[itab]); + for i := 0 to L - 1 do + with HEdges[itab][i] do + if (Tiles[0] = tile1) and (Tiles[1] = tile2) then + begin + Inc (Count, Cnt); + Exit; + end; + SetLength (HEdges[itab], L + 1); + with HEdges[itab][L] do + begin + Tiles[0] := tile1; + Tiles[1] := tile2; + Count := Cnt; + end; + aHEdgeCount[itab] := L + 1; + end; + + procedure AddVEdge (tile1, tile2, Cnt: Integer); + var + i, L: Integer; + begin + L := Length (VEdges[itab]); + for i := 0 to L - 1 do + with VEdges[itab][i] do + if (Tiles[0] = tile1) and (Tiles[1] = tile2) then + begin + Inc (Count, Cnt); + Exit; + end; + SetLength (VEdges[itab], L + 1); + with VEdges[itab][L] do + begin + Tiles[0] := tile1; + Tiles[1] := tile2; + Count := Cnt; + end; + aVEdgeCount[itab] := L + 1; + end; + + var + tile, edge, L, i: Integer; + begin + for tile := 0 to Length (aMCRSur[itab]) - 1 do + begin + edge := 6; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddHEdge (tile, aMCRSur[itab][tile][edge][i], aMCRSur[itab][tile][edge][i + 1]); + edge := 1; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddHEdge (aMCRSur[itab][tile][edge][i], tile, aMCRSur[itab][tile][edge][i + 1]); + + edge := 4; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddVEdge (tile, aMCRSur[itab][tile][edge][i], aMCRSur[itab][tile][edge][i + 1]); + edge := 3; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddVEdge (aMCRSur[itab][tile][edge][i], tile, aMCRSur[itab][tile][edge][i + 1]); + end; + end; + + + procedure SortMCRSur; + var + tile, edge, L, i, j, t1, t2, n1, n2: Integer; + begin + for tile := 0 to Length (aMCRSur[itab]) - 1 do + for edge := 0 to 7 do + begin + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + for j := i + 2 to L - 1 do + if j mod 2 = 0 then + begin + t1 := aMCRSur[itab][tile][edge][i]; + t2 := aMCRSur[itab][tile][edge][j]; + n1 := aMCRSur[itab][tile][edge][i + 1]; + n2 := aMCRSur[itab][tile][edge][j + 1]; + if n1 < n2 then + begin + aMCRSur[itab][tile][edge][i] := t2; + aMCRSur[itab][tile][edge][j] := t1; + aMCRSur[itab][tile][edge][i + 1] := n2; + aMCRSur[itab][tile][edge][j + 1] := n1; + end; + end; + end; + end; + + + function GetMostSurTile (itab, tile, edge: Integer): Integer; + + procedure RemoveMCRSur (P: Integer); + var + i, L: Integer; + begin + L := Length (aMCRSur[itab][tile][edge]); + for i := P to L - 2 - 1 do + aMCRSur[itab][tile][edge][i] := aMCRSur[itab][tile][edge][i + 2]; + SetLength (aMCRSur[itab][tile][edge], L - 2); + end; + + var + i, j, k, L, M, N, C: Integer; + TT, TransTile, TC, TransCount: Integer; + begin { GetMostSurTile } + M := -1; + N := -1; + TransTile := -1; + TransCount := 0; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + begin + C := aMCRSur[itab][tile][edge][i + 1]; + + TT := aMCRSur[itab][tile][edge][i]; + TC := aTrans[itab][TT][edge]; + if TC > TransCount then + begin + TransCount := TC; + TransTile := TT; + end; + + k := aSameAs[itab][aMCRSur[itab][tile][edge][i]][7 - edge]; + while k > -1 do + begin + for j := 0 to L - 1 do + if j mod 2 = 0 then + if aMCRSur[itab][tile][edge][j] = k then + Inc (C, aMCRSur[itab][tile][edge][j + 1]); + k := aSameAs[itab][k][7 - edge]; + end; + + if C > N then + begin + N := C; + M := aMCRSur[itab][tile][edge][i]; + end; + end; + + if TransCount = 0 then + begin + k := M; + while k > -1 do + begin + for j := Length (aMCRSur[itab][tile][edge]) - 1 downto 0 do + if j mod 2 = 0 then + if aMCRSur[itab][tile][edge][j] = k then + RemoveMCRSur (j); + k := aSameAs[itab][k][7 - edge]; + end; + Result := M; + end + else + Result := TransTile; + end; + + + function RunCode: string; + var + CurPos: Integer; + ErrorPos: Integer; + ErrorMsg: string; + + WritingFile: Boolean; + WritingBinFile: Boolean; // 2.5 + DefaultBinFileBits: Integer; + + ReadingTextFile: Boolean; // 3.0 + ReadingBinFile: Boolean; + InputFileName: string; + InputFilePos: LongInt; + TI: TextFile; + FI: file of Byte; + + + + procedure CodeError (P: Integer; Msg: string); + var + i, Line: Integer; + S: string; + begin + if not Error then + begin + Line := 0; + i := 1; + S := ''; + while i < P do + begin + if i <= Length (code) then + begin + if code[i] = #0 then + begin + S := ''; + Inc (Line); + end + else + S := S + code[i]; + Inc (i); + end; + end; + while (i <= Length (code)) and (code[i] <> #0) do + begin + S := S + code[i]; + Inc (i); + end; + Error := TRUE; + ErrorMsg := 'Error in line ' + IntToStr (Line) + ':'#13#10 + + S + #13#10 + + Msg; + ErrorPos := P; + end; + end; + + function GetToken: string; + var + s: string; + begin + Quote := FALSE; + GetToken := ''; + if CurPos > Length (code) then + Exit + else + begin + s := ''; + if code[CurPos] in ['a'..'z', 'A'..'Z', '0'..'9'] then + repeat + s := s + code[CurPos]; + Inc (CurPos); + until not (code[CurPos] in ['a'..'z', 'A'..'Z', '0'..'9']) + else + begin + s := code[CurPos]; + Inc (CurPos); + if s = '\' then + begin + Quote := TRUE; + s := code[CurPos]; + Inc (CurPos); + if s = 'n' then + s := #13#10; + if s = 'b' then + s := #8; + if s = 't' then + s := #9; + // if s = '0' then // 2.0 + // s := #0; // #0: eof + end; + end; + GetToken := s; + end; + end; + + function LookAheadToken: string; + var + oldpos: Integer; + begin + oldpos := CurPos; + ReadingAhead := TRUE; + LookAheadToken := GetToken; + ReadingAhead := FALSE; + CurPos := oldpos; + end; + + function GetLine: string; + var + t, s: string; + begin + t := ''; + repeat + s := LookAheadToken; + if s <> #0 then + t := t + GetToken; + until (s = '') or (s = #0); + GetLine := t; + end; + + function UGetToken: string; + begin + UGetToken := UpCaseStr (GetToken); + end; + + function USGetToken: string; + var + s: string; + begin + repeat + s := UpCaseStr (GetToken); + until s <> ' '; + USGetToken := s; + end; + + procedure FindEnd (Token: string); + var + s: string; + P: Integer; + RecursiveCount: Integer; + label + again; + begin + P := CurPos; + RecursiveCount := 0; + again: + repeat + s := GetToken; + until ((s = #0) and (LookAheadToken = '#')) or + (s = ''); + if s = '' then + begin + CodeError (P, 'No matching #END ' + Token + ' found'); + Exit; + end; + s := GetToken; // '#' + s := UGetToken; + if s = Token then + begin + Inc (RecursiveCount); + goto again; + end; + if s <> 'END' then + goto again; + if USGetToken <> Token then + goto again; + if RecursiveCount > 0 then + begin + Dec (RecursiveCount); + goto again; + end; + end; + + function GetString: string; + var + s, t: string; + P: Integer; + begin + t := ''; + while LookAheadToken = ' ' do + s := GetToken; + s := GetToken; + if s = #0 then + begin + GetString := ''; + Dec (CurPos); + Exit; + end; + if s = '"' then + begin + P := CurPos; + while LookAheadToken <> '"' do + begin + s := GetToken; + t := t + s; + if s = '' then + begin + CodeError (P, 'Unterminated string'); + Exit; + end; + end; + s := GetToken; + end + else // allow '...' as well as "..." + if s = #39 then + begin + P := CurPos; + while LookAheadToken <> #39 do + begin + s := GetToken; + t := t + s; + if s = '' then + begin + CodeError (P, 'Unterminated string'); + Exit; + end; + end; + s := GetToken; + end + else + begin + repeat + t := t + s; + s := GetToken; + until (s = ' ') or (s = #0) or (s = ''); + if s <> '' then + Dec (CurPos); + end; + GetString := t; + end; + + + function GetTokenSpecial: string; + var + s, t, u, v, fmt: string; + oldpos, erp: Integer; + Number: Integer; + NumberBytes: packed array[0..3] of Byte absolute Number; + F: ShortString; + i, bits: Integer; + begin + if WritingBinFile and (not Quote) and (LookAheadToken = '"') then // 2.5 + begin + GetTokenSpecial := GetString; + Exit; + end + else + t := GetToken; + + if (t = '<') and (not Quote) then + begin + NumericExpr := TRUE; + + oldpos := CurPos; + t := ''; + repeat + s := GetToken; + if (ValidNumber (s)) or + ((Length (s) = 1) and (s[1] in ExprChars)) then + t := t + s + else + t := t + GetVarValue (s, '%d'); + u := LookAheadToken; + until (u = ':') or (u = '>') or (u = #0); + u := GetToken; + + if u = ':' then + begin + fmt := GetString; + u := GetToken; + end + else + if WritingBinFile then + fmt := IntToStr (DefaultBinFileBits) + else + fmt := '%d'; + + if (s = '<') or (u <> '>') then + begin + CurPos := oldpos; + if s = '<' then + t := GetToken; + GetTokenSpecial := t; + Exit; + end; + + if NumericExpr then + begin + F := t; + if not Evaluate (Number, F, Erp) then + Error := TRUE + else + begin + + if WritingBinFile then + begin + bits := -1; + if (ValidNumber (Fmt)) then + bits := StrToInt (Fmt); + + if bits = -1 then + Error := TRUE + else + begin + if bits < 0 then // 2.52 - big endian + begin + bits := Abs (bits); + asm + push ebx + mov eax, Number + mov ecx, bits + mov ebx, 0 + @@1: + shr eax, 1 + rcl ebx, 1 + dec ecx + jnz @@1 + + mov Number, ebx + pop ebx + end; + end; + + v := ''; + for i := 0 to bits div 8 - 1 do + v := v + Chr (NumberBytes[i]); + GetTokenSpecial := #0 + v + #0; + end; + + end + else + begin + v := Format (Fmt, [Number]); + GetTokenSpecial := AddLeadingZeros (v, Fmt); + end; + + end; + end + else + GetTokenSpecial := t; + + if Error then + begin + Error := FALSE; + if NumericExpr then + CodeError (oldpos, 'Error in expression (' + t + ').') + else + CodeError (oldpos, 'Unknown variable (' + t + ').'); + end; + + end + else + GetTokenSpecial := t; + end; + + + function GetStringOrToken: string; + begin + Result := GetString; + exit; + + while LookAheadToken = ' ' do + GetToken; + if LookAheadToken = #0 then + GetStringOrToken := '' + else + if (not WritingBinFile) or (LookAheadToken = '"') then + GetStringOrToken := GetString + else + GetStringOrToken := GetTokenSpecial; + end; + + + function GetFilename: string; + var + s, t: string; + begin + repeat + s := GetTokenSpecial; + until s <> ' '; + t := s; + while (s <> '') and (s <> ' ') and (s <> #0) do + begin + s := GetTokenSpecial; + t := t + s; + end; + if s <> '' then + begin + Dec (CurPos); + if t <> '' then + Delete (t, Length (t), 1); // bug fix 2.5 (saving .PNG files) + end; + + if (t[1] in ['"', #39]) and (t[Length (t)] = t[1]) then + t := Copy (t, 2, Length (t) - 2); + + GetFilename := t; + end; + + + function AdjustFilename (Filename: string; Path: string): string; + begin + if (Filename = '') or (Pos (':', Filename) = 2) or (Filename[1] = '\') then + AdjustFilename := Filename + else + AdjustFilename := Path + Filename; + end; + + + function GetTextFileLineCount (Filename: string): LongInt; + var + TF: TextFile; + N: LongInt; + begin + if not FileExists (Filename) then + begin + GetTextFileLineCount := 0; + Exit; + end; + AssignFile (TF, Filename); + N := 0; + Reset (TF); + while not Eof (TF) do + begin + ReadLn (TF); + Inc (N); + end; + CloseFile (TF); + GetTextFileLineCount := N; + end; + + function GetBinFileSize (Filename: string): LongInt; + var + F: file of Byte; + begin + AssignFile (F, Filename); + Reset (F); + GetBinFileSize := FileSize (F); + CloseFile (F); + end; + + + function GetValidTileSet: Boolean; + begin + GetValidTileSet := TRUE; + while itab < Tab.Tabs.Count do + with TileTab[itab] do + begin + if not TileTab[itab].tbr.SkipExport then // 2.2 + begin + ValidTileSet := TRUE; + ValidTSTileSet := TRUE; + if (bmpFinal[itab].Height > 0) then + Exit; + ValidTileSet := FALSE; + if (tbr.TileCount > 0) then + Exit; + ValidTSTileSet := FALSE; + end; + Inc (itab); + end; + ValidTileSet := FALSE; + ValidTSTileSet := FALSE; + GetValidTileSet := FALSE; + end; + + + // 2.4 + function InitCornerVars: Boolean; // false if no more corners + var + i: Integer; + begin + InitCornerVars := FALSE; + SetNumVar ('CornerNumber', -1); + if TexTiles then + begin + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if icorner = Number then + begin + SetNumVar ('TopLeftTile', Tiles[0]); + SetNumVar ('TopRightTile', Tiles[1]); + SetNumVar ('BottomLeftTile', Tiles[2]); + SetNumVar ('BottomRightTile', Tiles[3]); + { + SetNumVar ('TopLeftColor', Colors[0]); + SetNumVar ('TopRightColor', Colors[1]); + SetNumVar ('BottomLeftColor', Colors[2]); + SetNumVar ('BottomRightColor', Colors[3]); + } + SetNumVar ('CornerNumber', icorner); + InitCornerVars := TRUE; + end; + end; + end; + + procedure InitHEdgeVars; + begin + SetNumVar ('HEdgeNumber', ihedge); + with HEdges[itab][ihedge] do + begin + SetNumVar ('TopTile', Tiles[0]); + SetNumVar ('BottomTile', Tiles[1]); + end; + end; + + procedure InitVEdgeVars; + begin + SetNumVar ('VEdgeNumber', ivedge); + with VEdges[itab][ivedge] do + begin + SetNumVar ('LeftTile', Tiles[0]); + SetNumVar ('RightTile', Tiles[1]); + end; + end; + + + + procedure InitPaletteVars; + var + s: string; + begin + SetNumVar ('PaletteNumber', ipal); + s := PaletteManager.GetID (ipal); + SetStrVar ('PaletteIdentifier', s); + if s = '' then + begin + SetNumVar ('PaletteSize', 0); + SetNumVar ('PalettePreset', 0); + end + else + begin + SetNumVar ('PaletteSize', aiPalSize[ipal]); + SetNumVar ('PalettePreset', aiPreset[ipal]); + end; + end; + + procedure InitTileSetVars; + var + R, G, B: Integer; + NH, NV: Integer; + N, MC: Integer; + begin + with TileTab[itab] do + begin + GetRGB (TRANS_COLOR, R, G, B); + NH := bmpFinal[itab].Width div tbr.W; + NV := bmpFinal[itab].Height div tbr.H; + + SetStrVar ('TileSetIdentifier', tab.Tabs[itab]); + SetNumVar ('TileSetNumber', itab); + SetNumVar ('TileWidth', tbr.W div GetTinyNH); + SetNumVar ('TileHeight', tbr.H div GetTinyNV); + + // SetNumVar ('TileCount', NH * NV); + if TinyTiles then + begin + SetNumVar ('TileCount', aFinalTinyTileCount[itab][NOFLIP]); + SetNumVar ('TSTileCount', tbr.TileCount * TinyNH * TinyNV); // 2.2 + end + else + begin + SetNumVar ('TileCount', aFinalTileCount[itab]); // 2.0 + SetNumVar ('TSTileCount', tbr.TileCount); // 2.2 + + if UTT then + SetNumVar ('UniqueTexTileCount', aUTTCount[itab]); // 2.5 + end; + + SetNumVar ('SequenceCount', 0); // 2.52 + SetNumVar ('MapCount', 0); // 2.53 + + if ValidTileSet then + begin + SetNumVar ('HorizontalTileCount', NH); + SetNumVar ('VerticalTileCount', NV); + SetNumVar ('TileSetBitmapWidth', bmpFinal[itab].Width); + SetNumVar ('TileSetBitmapHeight', bmpFinal[itab].Height); + SetNumVar ('TransparentPosX', TransX[itab]); // 2.0 update documentation! + SetNumVar ('TransparentPosY', TransY[itab]); + + // SetNumVar ('MapCount', Length (tbr.Maps.aMaps)); + MC := 0; + for N := 0 to Length (tbr.Maps.aMaps) - 1 do // 2.53: fixed: MapCount doesn't include skipped maps + if not tbr.Maps.aMaps[N].SkipExport then Inc (MC); // 2.55: fixed MapCount + SetNumVar ('MapCount', MC); + + SetNumVar ('SequenceCount', Length (tbr.Seq.aMaps)); + end + else // 3.0 + if (tbr.LastExportW <> 0) and (tbr.LastExportH <> 0) then + begin + SetNumVar ('HorizontalTileCount', tbr.LastExportW div tbr.W); + SetNumVar ('VerticalTileCount', tbr.LastExportH div tbr.H); + SetNumVar ('TileSetBitmapWidth', tbr.LastExportW); + SetNumVar ('TileSetBitmapHeight', tbr.LastExportH); + SetNumVar ('TransparentPosX', tbr.LastExportTransX); + SetNumVar ('TransparentPosY', tbr.LastExportTransY); + end; + + SetNumVar ('TransparentColorR', R); + SetNumVar ('TransparentColorG', G); + SetNumVar ('TransparentColorB', B); + GetRGB (BackGrColor, R, G, B); + SetNumVar ('BackgroundColorR', R); + SetNumVar ('BackgroundColorG', G); + SetNumVar ('BackgroundColorB', B); + + SetNumVar ('Overlap', tbr.Overlap); // 2.0 + + // 2.0 + // if ipal = -1 then // bug fix 2.34 (caused all tile sets to use first palette) + begin + ipal := tbr.PaletteNumber; + InitPaletteVars; + end; + + // 2.4 + if TexTiles then + begin + SetNumVar ('CornerCount', aCornerCount[itab]); + SetNumVar ('HEdgeCount', aHEdgeCount[itab]); + SetNumVar ('VEdgeCount', aVEdgeCount[itab]); + end; + + SetEdgeRects (tbr.W, tbr.H); // 2.5 + end; + end; + + + procedure InitTileVars (Tile0: Boolean); + + procedure InitSurVar (VarName: string; Edge: Integer); + var + it: Integer; + begin + if Tile0 then + it := 0 + else + it := itile + 1; + SetNumVar (VarName, 0); + if TexTiles and (iutt < 0) then + if it < Length (aMCRSur[itab]) then + SetNumVar (VarName, Integer (Boolean (Length (aMCRSur[itab][it][Edge]) <> 0))) + end; + + begin { InitTileVars } + + if tile0 then + SetNumVar ('TileNumber', -1) + else + if iutt >= 0 then + SetNumVar ('TileNumber', iutt) + else + if itstile >= 0 then + SetNumVar ('TileNumber', itstile) + else + SetNumVar ('TileNumber', itile); + + // 2.4 + InitSurVar ('OtherTopLeftCorners', 0); + InitSurVar ('OtherTopEdges', 1); + InitSurVar ('OtherTopRightCorners', 2); + InitSurVar ('OtherLeftEdges', 3); + InitSurVar ('OtherRightEdges', 4); + InitSurVar ('OtherBottomLeftCorners', 5); + InitSurVar ('OtherBottomEdges', 6); + InitSurVar ('OtherBottomRightCorners', 7); + + // 2.5 + if TexTiles then + begin + SetNumVar ('UniqueTexTileNumber', iutt); + end; + end; + + + // 2.4 + procedure InitPixelVars (RGB: Integer; A: Integer); + var + i, R, G, B: Integer; + rr, gg, bb, index, tmp, best: Integer; + begin + GetRGB (RGB, R, G, B); + SetNumVar ('RGB', RGB); + + SetNumVar ('R', R); + SetNumVar ('G', G); + SetNumVar ('B', B); + + if A > 255 then A := 255 else if A < 0 then A := 0; + SetNumVar ('A', A); + + SetNumVar ('Pixel', 0); + + if (ipal >= 0) and (Length (aaiPal) > 0) then + if Length (aaiPal[ipal]) > 0 then + begin + best := -1; + index := -1; + + for i := 0 to { Length (aaiPal[ipal]) } aiPalSize[ipal] - 1 do // 2.41 + begin + GetRGB (aaiPal[ipal][i], rr, gg, bb); + tmp := sqr ((R - rr) * 2) + sqr ((G - gg) * 2) + sqr ((B - bb) * 2); + if (index = -1) or (tmp < best) then + begin + index := i; + best := tmp; + end; + end; + SetNumVar ('Pixel', index); + end; + + if RGB = TRANS_COLOR then + begin + SetNumVar ('Pixel', -1); + SetNumVar ('A', 0); + end; + + CurRGB := RGB; // 2.54 + end; + + + function InitHEdgeDatVars: Boolean; + var + i, j: Integer; + RGB: Integer; + A: Integer; + begin + with TileTab[itab] do + begin + with HEdges[itab][ihedge] do + begin + i := 1 + (ihedgedat mod tbr.W); + if ihedgedat div tbr.W = 0 then + j := (Tiles[0] - 1) * (tbr.H + 2) + tbr.H + else + j := (Tiles[1] - 1) * (tbr.H + 2) + 1; + + if j < 0 then + RGB := TRANS_COLOR + else + RGB := bmpTexTiles[itab].Canvas.Pixels[i, j]; + + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[i, j]; + InitPixelVars (RGB, A); + + SetNumVar ('X', ihedgedat mod tbr.W); + SetNumVar ('Y', ihedgedat div tbr.W); + end; + end; + InitHEdgeDatVars := RGB <> TRANS_COLOR; + end; + + + function InitVEdgeDatVars: Boolean; + var + i, j: Integer; + RGB: Integer; + A: Integer; + begin + with TileTab[itab] do + begin + with VEdges[itab][ivedge] do + begin + if ivedgedat mod 2 = 0 then + i := tbr.W + else + i := 1; + j := (Tiles[ivedgedat mod 2] - 1) * (tbr.H + 2) + (ivedgedat div 2) + 1; + if j < 0 then + RGB := TRANS_COLOR + else + RGB := bmpTexTiles[itab].Canvas.Pixels[i, j]; + + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[i, j]; + InitPixelVars (RGB, A); + + SetNumVar ('X', ivedgedat mod 2); + SetNumVar ('Y', ivedgedat div 2); + end; + end; + InitVEdgeDatVars := RGB <> TRANS_COLOR; + end; + + + function InitCornerDatVars: Boolean; + var + i: Integer; + RGB: Integer; + begin + RGB := TRANS_COLOR; + { SetNumVar ('CornerNumber', -1); } + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if icorner = Number then + begin + RGB := Colors[icornerdat]; + InitPixelVars (RGB, 255); + { SetNumVar ('Index', icornerdat); } + SetNumVar ('X', icornerdat mod 2); + SetNumVar ('Y', icornerdat div 2); + end; + InitCornerDatVars := RGB <> TRANS_COLOR; + end; + + + + { + procedure InitTinyTileVars; + begin + SetNumVar ('TinyTileNumber', itinytile); + end; + } + + { + function InitTinyTileDatVars: Boolean; + var + x, y: Integer; + i, RGB, R, G, B: Integer; + rr, gg, bb, index, tmp, best: Integer; + begin + with TileTab[itab] do + begin + GetTinyPos (itab, aFinalTinyTiles[itab][TinyFlip][itinytile], x, y); + Inc (x, idat mod TinyW); + Inc (y, idat div TinyH); + + RGB := bmpFinal[itab].Canvas.Pixels[x, y]; + + InitPixelVars (RGB, 255); + end; + InitTinyTileDatVars := RGB <> TRANS_COLOR; + end; + } + + // returns FALSE if pixel is transparent + function InitTileDatVars: Boolean; + var + NH, x, y: Integer; + tbrtilenr, tinytilenr: Integer; + RGB: Integer; + xpos, ypos: Integer; // 2.34 + A: Integer; // 2.5 + i, j, k: Integer; + rr, gg, bb: Integer; + tr, tg, tb, ta: Integer; + begin + with TileTab[itab] do + begin + if itstile >= 0 then + begin + if TinyTiles then + begin + + // if 4 * itstile div (TinyNH * TinyNV) > 0 then + // asm nop end; + + tbrtilenr := itstile div (TinyNH * TinyNV); + tinytilenr := itstile mod (TinyNH * TinyNV); + x := tbr.w * tbrtilenr; + y := 0; + Inc (x, (tinytilenr mod TinyNH) * TinyW); + Inc (y, (tinytilenr div TinyNH) * TinyH); + { + x := tbr.W * itstile div (TinyNH * TinyNV) + + TinyW * ((itstile mod (TinyNH * TinyNV)) mod TinyNH); + y := TinyH * ((itstile mod (TinyNH * TinyNV)) div TinyNH); + } + XPos := idat mod TinyW; + YPos := idat div TinyW; + end + else + begin { not tinytiles } + x := tbr.W * itstile; + y := 0; + XPos := idat mod tbr.W; + YPos := idat div tbr.W; + end; + + if aa then + begin + tr := 0; tg := 0; tb := 0; ta := 0; + k := 0; + + for j := 0 to aaY - 1 do + for i := 0 to aaX - 1 do + begin + RGB := tbr.TileBitmap.Canvas.Pixels[x * aaX + XPos * aaX + i, y * aaY + YPos * aaY + j]; + if RGB <> TRANS_COLOR then + begin + GetRGB (RGB, rr, gg, bb); + Inc (tr, rr); + Inc (tg, gg); + Inc (tb, bb); + Inc (ta, 255); + Inc (k); + end; + end; + if ta = 0 then + begin + RGB := TRANS_COLOR; + A := 0; + end + else + begin + RGB := (tr div k) + ((tg div k) shl 8) + ((tb div k) shl 16); + A := ta div (aaX * aaY); + end; + + end + else + begin + RGB := tbr.TileBitmap.Canvas.Pixels[x + XPos, y + YPos]; + A := 255; + end; + + end + else + begin { itstile = -1 } + + if TinyTiles then + begin + GetTinyPos (itab, aFinalTinyTiles[itab][TinyFlip][itile], x, y); + XPos := idat mod TinyW; + YPos := idat div TinyW; + if (x = -1) or (y = -1) then + begin + RGB := TRANS_COLOR; + A := 0; + end + else + begin + Inc (x, XPos); + Inc (y, YPos); + RGB := bmpFinal[itab].Canvas.Pixels[x, y]; + if aa then + A := bmpAlpha[itab].Canvas.Pixels[x, y] + else + A := 255; + end; + end + else + begin { not TinyTiles } + NH := bmpFinal[itab].Width div tbr.W; + x := (itile mod NH) * tbr.W; + y := (itile div NH) * tbr.H; + XPos := idat mod tbr.W; + YPos := idat div tbr.W; + Inc (x, XPos); + Inc (y, YPos); + RGB := bmpFinal[itab].Canvas.Pixels[x, y]; + if aa then + A := bmpAlpha[itab].Canvas.Pixels[x, y] + else + A := 255; + end; + + end; + + InitPixelVars (RGB, A); + + // 2.34 + SetNumVar ('X', XPos); + SetNumVar ('Y', YPos); + + end; + InitTileDatVars := RGB <> TRANS_COLOR; + end; + + + + // 2.4 + function InitTexTileDatVars: Boolean; // FALSE: transparent + var + NH, x, y: Integer; + xpos, ypos: Integer; + RGB: Integer; + t, tile, j, k, l, edge: Integer; + tmpx, tmpy: Integer; + A: Integer; + + function Inside (X, Y: Integer; R: TRect): Boolean; + begin + Inside := (X >= R.Left) and (X < R.Right) and + (Y >= R.Top) and (Y < R.Bottom); + end; + + begin + with TileTab[itab] do + begin + NH := bmpTexTiles[itab].Width div (tbr.W + 2); + + if UTT and (iutt >= 0) then + begin + t := aUTTIndex[itab][iutt] - 1; + tile := t; + XPos := idat mod (tbr.W + 2); + YPos := (idat div (tbr.W + 2)) mod (tbr.H + 2); + tmpx := XPos; + tmpy := YPos; + + { + tmpx := XPos - EdgeDst[edge].Left + EdgeSrc[7 - edge].Left; + tmpy := YPos - EdgeDst[edge].Top + EdgeSrc[7 - edge].Top; + } + + for edge := 0 to 7 do + if Inside (XPos, YPos, EdgeDst[edge]) then + if (t + 1 < Length (aUTTRef[itab])) then + begin + + l := Length (aUTTRef[itab][t + 1]); + for j := 0 to l - 1 do + if aUTTRef[itab][t + 1][j][8] = iutt + 1 then + begin + k := aUTTRef[itab][t + 1][j][edge]; + if EdgeToCorner[edge] = -1 then + tile := k - 1 + else + tile := Corners[itab][k].Tiles[EdgeToCorner[7 - edge]] - 1; + tmpx := XPos - EdgeDst[edge].Left + EdgeSrc[edge].Left; + tmpy := YPos - EdgeDst[edge].Top + EdgeSrc[edge].Top; + end; + end; + + if tile = -1 then + begin + RGB := TRANS_COLOR; + A := 0; + end + else + begin + x := (tile mod NH) * (tbr.W + 2); + y := (tile div NH) * (tbr.H + 2); + Inc (x, tmpx); + Inc (y, tmpy); + RGB := bmpTexTiles[itab].Canvas.Pixels[x, y]; + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[x, y]; + end; + + end + else + begin + x := (itile mod NH) * (tbr.W + 2); + y := (itile div NH) * (tbr.H + 2); + XPos := idat mod (tbr.W + 2); + YPos := idat div (tbr.W + 2); + Inc (x, XPos); + Inc (y, YPos); + RGB := bmpTexTiles[itab].Canvas.Pixels[x, y]; + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[x, y]; + end; + + InitPixelVars (RGB, A); + + SetNumVar ('X', XPos); + SetNumVar ('Y', YPos); + end; + InitTexTileDatVars := RGB <> TRANS_COLOR; + end; + + + procedure InitMapVars; + begin + with TileTab[itab].tbr.Maps.aMaps[imap] do + begin + SetStrVar ('MapIdentifier', ID); + SetNumVar ('MapNumber', imap); + MapHt := Length (Map) * GetTinyNV; + if MapHt = 0 then + MapWd := 0 + else + MapWd := Length (Map[0]) * GetTinyNH; + SetNumVar ('MapHeight', MapHt); + SetNumVar ('MapWidth', MapWd); + SetStrVar ('ScrollX', fx); // 2.0 update documentation! + SetStrVar ('ScrollY', fy); + + end; + end; + + + procedure InitTileMapVars; + var + x, y: Integer; + begin + if not TinyTiles then + Exit; + + x := itilemap mod TinyNH; + y := (itilemap div TinyNH) mod TinyNV; + + SetNumVar ('TinyTileNumber', aFinalTinyRef[itab][itile * 4 + itilemap][NOFLIP]); // ???????? + + SetNumVar ('X', x); + SetNumVar ('Y', y); + end; + + + procedure InitMCRVars (mcr: MapCellRec); + var + TotalOfsX, + TotalOfsY: Integer; // 2.4 + + procedure AddOfs (tile: Integer); + begin + tile := tile and TILE_MASK; + with TileTab[itab].tbr do + begin + if tile < Length (OffsetX) then + Inc (TotalOfsX, OffsetX[tile]); + if tile < Length (OffsetY) then + Inc (TotalOfsY, OffsetY[tile]); + end; + end; + + begin + TotalOfsX := 0; + TotalOfsY := 0; + + // if mcr.Bounds = $FF then + if mcr.Bounds and $40 <> 0 then + begin + // SetNumVar ('TSBackTile', -1); // 2.2 + SetNumVar ('TSBackTile', -(mcr.MapCode + 1)); + SetNumVar ('TSBackTile1', -(mcr.MapCode + 1)); // 2.53 + SetNumVar ('TSBackHF', 0); + SetNumVar ('TSBackVF', 0); + SetNumVar ('TSBackR', 0); + // SetNumVar ('TSMidTile', -1); + SetNumVar ('TSMidTile', -(mcr.MapCode + 1)); + SetNumVar ('TSMidTile1', -(mcr.MapCode + 1)); + SetNumVar ('TSMidHF', 0); + SetNumVar ('TSMidVF', 0); + SetNumVar ('TSMidR', 0); + // SetNumVar ('TSFrontTile', -1); + SetNumVar ('TSFrontTile', -(mcr.MapCode + 1)); + SetNumVar ('TSFrontTile1', -(mcr.MapCode + 1)); + SetNumVar ('TSFrontHF', 0); + SetNumVar ('TSFrontVF', 0); + SetNumVar ('TSFrontR', 0); + end + else + begin + if mcr.Back = -1 then + begin + SetNumVar ('TSBackTile', -1); + SetNumVar ('TSBackTile1', 0); + SetNumVar ('TSBackHF', 0); + SetNumVar ('TSBackVF', 0); + SetNumVar ('TSBackR', 0); + end + else + begin + AddOfs (mcr.Back); + SetNumVar ('TSBackTile', mcr.Back and TILE_MASK); + SetNumVar ('TSBackTile1', (mcr.Back and TILE_MASK) + 1); + SetNumVar ('TSBackHF', Byte (mcr.Back and MIRROR_MASK <> 0)); + SetNumVar ('TSBackVF', Byte (mcr.Back and UPS_MASK <> 0)); + SetNumVar ('TSBackR', Byte (mcr.Back and ROTATE_MASK <> 0)); + end; + + if mcr.Mid = -1 then + begin + SetNumVar ('TSMidTile', -1); + SetNumVar ('TSMidTile1', 0); + SetNumVar ('TSMidVF', 0); + SetNumVar ('TSMidHF', 0); + SetNumVar ('TSMidR', 0); + end + else + begin + AddOfs (mcr.Mid); + SetNumVar ('TSMidTile', mcr.Mid and TILE_MASK); + SetNumVar ('TSMidTile1', (mcr.Mid and TILE_MASK) + 1); + SetNumVar ('TSMidHF', Byte (mcr.Mid and MIRROR_MASK <> 0)); + SetNumVar ('TSMidVF', Byte (mcr.Mid and UPS_MASK <> 0)); + SetNumVar ('TSMidR', Byte (mcr.Mid and ROTATE_MASK <> 0)); + end; + + if mcr.Front = -1 then + begin + SetNumVar ('TSFrontTile', -1); + SetNumVar ('TSFrontTile1', 0); + SetNumVar ('TSFrontHF', 0); + SetNumVar ('TSFrontVF', 0); + SetNumVar ('TSFrontR', 0); + end + else + begin + AddOfs (mcr.Front); + SetNumVar ('TSFrontTile', mcr.Front and TILE_MASK); + SetNumVar ('TSFrontTile1', (mcr.Front and TILE_MASK) + 1); + SetNumVar ('TSFrontHF', Byte (mcr.Front and MIRROR_MASK <> 0)); + SetNumVar ('TSFrontVF', Byte (mcr.Front and UPS_MASK <> 0)); + SetNumVar ('TSFrontR', Byte (mcr.Front and ROTATE_MASK <> 0)); + end; + end; + + SetNumVar ('OffsetX', TotalOfsX); + SetNumVar ('OffsetY', TotalOfsY); + end; + + procedure InitMapDatVars; + var + x, y, i, j: Integer; + mcr: MapCellRec; + begin + with TileTab[itab].tbr.Maps.aMaps[imap] do + begin + y := idat div MapWd; + x := idat mod MapWd; + mcr := Map[y div GetTinyNV, x div GetTinyNH]; + InitMCRVars (mcr); + // if mcr.Bounds = $FF then + if mcr.Bounds and $40 <> 0 then + begin + i := mcr.MapCode; + j := -(i + 1); + // if mcr.Bounds and $7F = 0 then // 2.55 + // mcr.Bounds := TileTab[itab].tbr.Seq.aMaps[i].Map[0, 0].Bounds; + end + else + begin + i := FindMCR (mcr); + j := aFinalRef[itab][i]; + end; + + if TinyTiles then + begin + if j > 0 then + begin + Dec (j); + j := aFinalTinyRef[itab][j * GetTinyNH * GetTinyNV + + (y mod GetTinyNV) * GetTinyNH + + (x mod GetTinyNH)][TinyFlip]; + { j := aFinalTinyTiles[itab][TinyFlip][j] + 1; } + end + else // 2.34 + if j < 0 then + begin + j := (j + 1) * GetTinyNH * GetTinyNV - 1 - + ((y mod GetTinyNV) * GetTinyNH + (x mod GetTinyNH)); + end; + end; { tinytiles } + + // 2.5 + if TexTiles then + begin + if j < 0 then + SetNumVar ('UniqueTexTileNumber', j) + else + SetNumVar ('UniqueTexTileNumber', mcr.Tag); + end; + + SetNumVar ('TileNumber', j); + SetNumVar ('TileNumberLoByte', j mod $100); + SetNumVar ('TileNumberHiByte', j div $100); + with mcr do + begin + if j < 0 then + MapCode := 0; + SetNumVar ('Bounds', Bounds and (not $40)); + SetNumVar ('MapCode', MapCode); + SetNumVar ('BoundMapValue', (Bounds and (not $40)) + (MapCode shl 8)); + end; + + // 2.34 + SetNumVar ('X', x); + SetNumVar ('Y', y); + + end; + end; + + procedure InitSeqVars; + var + m, c: Integer; + i, j, k: Integer; + Count: Integer; + { LastSize: Integer; } + isq: Integer; + nvh: Integer; + // x, y: Integer; + s: string[255]; + begin + nvh := GetTinyNH * GetTinyNV; // 2.34 tinytiles sequences + isq := iseq div nvh; + k := iseq mod nvh; + // x := k mod GetTinyNH; + // y := k div GetTinyNH; + + SeqFrames := 0; + if Length (TileTab[itab].tbr.Seq.aMaps) <= 0 then + SeqLen := 0 + else + with TileTab[itab].tbr.Seq.aMaps[isq] do + begin + if Length (Map) < 1 then + SeqLen := 0 + else + begin + SeqLen := Length (Map[0]); + for i := 0 to SeqLen - 1 do // 3.0 + Inc (SeqFrames, 1 + Map[0][i].MapCode); + end; + + SetStrVar ('SpriteName', tab.Tabs[itab]); + SetNumVar ('SpriteNumber', iseq); + { LastSize := -1; } + with TileTab[itab].tbr.Maps do + for m := 0 to Length (aMaps) - 1 do + with aMaps[m] do + begin + Count := 0; + s := ''; + if Length (Map) > 0 then + { if (LastSize = -1) or + (Length (Map) * Length (Map[0]) <= LastSize) then } + begin + { LastSize := Length (Map) * Length (Map[0]); } + for j := 0 to Length (Map) - 1 do + for i := 0 to Length (Map[j]) - 1 do + // if (Map[j, i].Bounds = $FF) then + if (Map[j, i].Bounds and $40 <> 0) then + begin + c := Map[j, i].MapCode; + // if Pos (Chr (c), s) = 0 then { huh??? } + begin + s := s + Chr (c); + Inc (Count); + + if c = isq then + begin + SetStrVar ('SpriteName', + TileTab[itab].tbr.Maps.aMaps[m].ID); + + if TinyTiles then + SetNumVar ('SpriteNumber', (Count - 1) * nvh + 1 + k) + else + SetNumVar ('SpriteNumber', Count); + end; + end; + end; + end; + end; + + // SetNumVar ('SpriteNumber', iseq); // 2.43 + SetNumVar ('SequenceNumber', iseq + 1); + end; + SetNumVar ('SequenceLength', SeqLen); + SetNumVar ('SpriteLength', SeqLen); + end; + + procedure InitPalDatVars; + var + i, R, G, B: Integer; + begin + i := aaiPal[ipal][ipaldat]; + SetNumVar ('RGB', i); + GetRGB (i, R, G, B); + SetNumVar ('Index', ipaldat); + SetNumVar ('R', R); + SetNumVar ('G', G); + SetNumVar ('B', B); + end; + + procedure InitSeqDatVars; + var + i, j, k: Integer; + mcr: MapCellRec; + isq, nvh: Integer; + // t, x, y: Integer; + begin + nvh := GetTinyNH * GetTinyNV; // 2.34 tinytiles sequences + isq := iseq div nvh; + k := iseq mod nvh; + + with TileTab[itab].tbr.Seq.aMaps[isq] do + begin + mcr := Map[0, iseqdat]; + InitMCRVars (mcr); + i := FindMCR (mcr); + j := aFinalRef[itab][i]; + + if TinyTiles then + if j > 0 then + begin + Dec (j); + j := aFinalTinyRef[itab][j * nvh + k][TinyFlip]; + end; + + SetNumVar ('TileNumber', j); + SetNumVar ('FrameCount', mcr.MapCode); + + // 2.5 + if TexTiles then + SetNumVar ('UniqueTexTileNumber', mcr.Tag); + + // 2.34 + SetNumVar ('Frame', iseqdat); + + + SetNumVar ('TileNumberLoByte', j mod $100); // 2.55 + SetNumVar ('TileNumberHiByte', j div $100); + with mcr do + begin + if j < 0 then + MapCode := 0; + SetNumVar ('Bounds', Bounds and (not $40)); + SetNumVar ('MapCode', MapCode); + SetNumVar ('BoundMapValue', (Bounds and (not $40)) + (MapCode shl 8)); + end; + + + end; + end; + + + procedure InitSeqFrameVars; + var + i, j, k: Integer; + mcr: MapCellRec; + isq, nvh: Integer; + // t, x, y: Integer; + begin + nvh := GetTinyNH * GetTinyNV; // 2.34 tinytiles sequences + isq := iseq div nvh; + k := iseq mod nvh; + + with TileTab[itab].tbr.Seq.aMaps[isq] do + begin + + i := iseqdat; + j := 0; + repeat + mcr := Map[0, j]; + Dec (i, mcr.MapCode + 1); + if i >= 0 then + Inc (j); + until (i < 0) or (j >= Length (Map[0])); + + InitMCRVars (mcr); + i := FindMCR (mcr); + j := aFinalRef[itab][i]; + + if TinyTiles then + if j > 0 then + begin + Dec (j); + j := aFinalTinyRef[itab][j * nvh + k][TinyFlip]; + end; + + SetNumVar ('TileNumber', j); + SetNumVar ('FrameCount', mcr.MapCode); + + // 2.5 + if TexTiles then + SetNumVar ('UniqueTexTileNumber', mcr.Tag); + + // 2.34 + SetNumVar ('Frame', iseqdat); + + + SetNumVar ('TileNumberLoByte', j mod $100); // 2.55 + SetNumVar ('TileNumberHiByte', j div $100); + with mcr do + begin + if j < 0 then + MapCode := 0; + SetNumVar ('Bounds', Bounds and (not $40)); + SetNumVar ('MapCode', MapCode); + SetNumVar ('BoundMapValue', (Bounds and (not $40)) + (MapCode shl 8)); + end; + + + end; + end; + + + procedure GetList (ListName: string; var str: TStringList); + var + i: Integer; + Copying: Boolean; + s, t: string; + lines: TStringList; + begin + str.Clear; + Copying := FALSE; + + // avoid strange bug (delphi 5): Lists.Notes.Lines.Count returns 0 if ListsForm hasn't been shown yet + lines := TStringList.Create(); + lines.Text := Lists.Notes.Lines.Text; + + //for i := 0 to Lists.Notes.Lines.Count - 1 do + for i := 0 to lines.Count - 1 do + begin + //s := Lists.Notes.Lines.Strings[i]; + s := lines.Strings[i]; + t := Trim (s); + if t = '' then + Copying := FALSE + else + if (t[1] = '[') and (t[Length(t)] = ']') then + Copying := FALSE; + if Copying then + str.Add (s); + if Trim (UpCaseStr (s)) = '[' + UpCaseStr (ListName) + ']' then + Copying := TRUE; + end; + end; + + + function GetListLength (ListName: string): Integer; + var + str: TStringList; + begin + str := TStringList.Create (); + GetList (ListName, str); + GetListLength := str.Count; + str.Free; + end; + + + procedure InitListVars (ListName: string; Index: Integer; Depth: Integer); + var + str: TStringList; + s: string; + begin + str := TStringList.Create (); + GetList (ListName, str); + if Index < str.Count then + begin + s := str[Index]; + SetNumVar ('Index', Index); + SetStrVar ('Item', s); + if ValidNumber (s) then SetNumVar ('ItemValue', StrToInt (s)); + SetNumVar (ListName + 'Index', Index); + SetStrVar (ListName + 'Item', s); + if ValidNumber (s) then SetNumVar (ListName + 'ItemValue', StrToInt (s)); + SetNumVar (ListName + 'Index' + IntToStr (Depth), Index); + SetStrVar (ListName + 'Item' + IntToStr (Depth), s); + if ValidNumber (s) then SetNumVar (ListName + 'ItemValue' + IntToStr (Depth), StrToInt (s)); + end; + str.Free; + end; + + + procedure InitFileDatVars; + var + s: string; + b: Byte; + begin + if ReadingTextFile then + begin + ReadLn (TI, s); + SetStrVar ('TextFileLine', s); + if ValidNumber (s) then SetNumVar ('TextFileLineValue', StrToInt (s)); + SetNumVar ('LineNumber', InputFilePos); + end; + if ReadingBinFile then + begin + BlockRead (FI, b, 1); + SetStrVar ('BinFileChar', Chr (b)); + SetNumVar ('BinFileByte', b); + SetNumVar ('BinFilePos', InputFilePos); + end; + Inc (InputFilePos); + end; + + + + // -------------- + + + procedure WidenBitmap (NewWidth: Integer); + var + W, H: Integer; + Wd, M, N: Integer; + x, y, i, j: Integer; + Found: Boolean; + begin + W := TileTab[itab].tbr.W; + H := TileTab[itab].tbr.H; + if (W = 0) or (bmpFinal[itab].Width <> W) then + Exit; + N := 1; + Wd := W; + while Wd + W <= NewWidth do + begin + Inc (Wd, W); + Inc (N); + end; + if N <= 1 then + Exit; + M := bmpFinal[itab].Height div H; + if M > N then + begin + j := (M + (N - 1)) div N; // height + i := j * N - M; // # unused + while i >= j do + begin + Dec (Wd, W); + Dec (N); + Dec (i, j); + end; + end; + with bmpFinal[itab] do + begin + Canvas.Brush.Color := TRANS_COLOR; + Width := Wd; + for i := 0 to M - 1 do + begin + x := (i mod N) * W; + y := (i div N) * H; + Canvas.CopyRect (MakeRect (x, y, W, H), Canvas, MakeRect (0, i * H, W, H)); + end; + Height := ((M + (N - 1)) div N) * H; + if M <= N then + Width := M * W; + + Found := FALSE; + for j := 0 to Height - 1 do + for i := 0 to Width - 1 do + if not Found then + if Canvas.Pixels[i, j] = TRANS_COLOR then + begin + TransX[itab] := i; + TransY[itab] := j; + Found := TRUE; + end; + + // if not Found then .... impossible! + end; + end; + + + type + CmdType = (ctFile, ctBinFile, ctTileSet, ctTile, ctTSTile, ctTinyTiles, + ctTileData, ctTexTileData, ctMap, ctMapData, + ctPalette, ctPaletteData, ctSequence, ctSequenceData, + ctSequenceFrame, // 3.00 + ctCorner, ctCornerData, + ctHEdge, ctHEdgeData, ctVEdge, ctVEdgeData, + ctTileMap, ctTile0, ctUTTile, + ctTileBitmap, ctTSTileBitmap, + ctList, + ctReadTextFile, ctReadBinFile + ); + + CommandRec = + record + KeyWord, + Parameters: string; + ReqCmd: set of CmdType; + idx: ^Integer; + NewLine: Boolean; + + sFilename, + sListName, + sBegin, + sSeparator, + sLongLineSeparator, + sNextSeparator, + sEnd, + sTrans: string; + + DataWidth, + DataHeight, + CodeStart: Integer; + end; + + const + SupportedCmds = [ctTile, ctTexTileData, ctCorner, ctCornerData, + ctMap, ctMapData, ctSequence, ctSequenceData, + ctSequenceFrame, + ctHEdge, ctHEdgeData, ctVEdge, ctVEdgeData, + ctTileData, ctTileMap, ctTile0, ctTSTile, + ctPalette, ctPaletteData, ctUTTile, + ctTileBitmap, ctTSTileBitmap, + ctList, + ctReadTextFile, ctReadBinFile + ]; + + const + Commands: array[CmdType] of CommandRec = + ( + ( KeyWord: 'FILE'; Parameters: 'F'; ReqCmd: []; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'BINFILE'; Parameters: 'FW'; ReqCmd: []; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'TILESET'; Parameters: 'S'; ReqCmd: []; idx: @itab; NewLine: TRUE; ), + ( KeyWord: 'TILE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @itile; NewLine: TRUE; ), + ( KeyWord: 'TSTILE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @itstile; NewLine: TRUE; ), + ( KeyWord: 'TINYTILES'; Parameters: 'WH'; ReqCmd: [ctTileSet]; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'TILEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctTile, ctTSTile]; idx: @idat; NewLine: FALSE; ), + ( KeyWord: 'TEXTILEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctTile, ctUTTile]; idx: @idat; NewLine: FALSE; ), + ( KeyWord: 'MAP'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @imap; NewLine: TRUE; ), + ( KeyWord: 'MAPDATA'; Parameters: 'BSLNE'; ReqCmd: [ctMap]; idx: @idat; NewLine: FALSE; ), + ( KeyWord: 'PALETTE'; Parameters: 'S'; ReqCmd: []; idx: @ipal; NewLine: TRUE; ), + ( KeyWord: 'PALETTEDATA'; Parameters: 'BSE'; ReqCmd: [ctPalette]; idx: @ipaldat; NewLine: FALSE; ), + ( KeyWord: 'SEQUENCE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @iseq; NewLine: TRUE; ), + ( KeyWord: 'SEQUENCEDATA'; Parameters: 'BSE'; ReqCmd: [ctSequence]; idx: @iseqdat; NewLine: FALSE; ), + ( KeyWord: 'SEQUENCEFRAME'; Parameters: 'BSE'; ReqCmd: [ctSequence]; idx: @iseqdat; NewLine: FALSE; ), + ( KeyWord: 'CORNER'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @icorner; NewLine: TRUE; ), + ( KeyWord: 'CORNERDATA'; Parameters: 'BSET'; ReqCmd: [ctCorner]; idx: @icornerdat; NewLine: FALSE; ), + ( KeyWord: 'HEDGE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @ihedge; NewLine: TRUE; ), + ( KeyWord: 'HEDGEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctHEdge]; idx: @ihedgedat; NewLine: FALSE; ), + ( KeyWord: 'VEDGE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @ivedge; NewLine: TRUE; ), + ( KeyWord: 'VEDGEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctVEdge]; idx: @ivedgedat; NewLine: FALSE; ), + ( KeyWord: 'TILEMAP'; Parameters: 'BSLNE'; ReqCmd: [ctTile, ctTSTile]; idx: @itilemap; NewLine: FALSE; ), + ( KeyWord: 'TILE0'; Parameters: ''; ReqCmd: [ctTileSet]; idx: @itile0; NewLine: TRUE; ), + ( KeyWord: 'UNIQUETEXTILE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @iutt; NewLine: TRUE; ), + ( KeyWord: 'TILEBITMAP'; Parameters: 'X'; ReqCmd: []; idx: @itb; NewLine: FALSE; ), + ( KeyWord: 'TSTILEBITMAP'; Parameters: 'X'; ReqCmd: []; idx: @itb; NewLine: FALSE; ), + ( KeyWord: 'LIST'; Parameters: 'PBSLE'; ReqCmd: []; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'READTEXTFILE'; Parameters: 'FBSLE'; ReqCmd: []; idx: @ifile; NewLine: FALSE; ), + ( KeyWord: 'READBINFILE'; Parameters: 'FBSLE'; ReqCmd: []; idx: @ifile; NewLine: FALSE; ) + ); + + + var + Done: Boolean; + s, t: string; + + FirstLine: Boolean; + WritingMapData: Boolean; + WritingTileData: Boolean; + WritingTexTileData: Boolean; + { WritingTinyTileData: Boolean; } + WritingSeqData: Boolean; + WritingSeqFrames: Boolean; // 3.0 + WritingPalData: Boolean; + WritingCornerData: Boolean; + OutputFileName: string; + OutputWidth: Integer; // 2.5 + F: TextFile; + TileSetStart, + MapStart, + MapDatStart, + TileStart, + TSTileStart, + { TinyTileStart, } + TileDatStart, + TexTileDatStart, + { TinyTileDatStart, } + SeqStart, + SeqDatStart, + PaletteStart, + PalDatStart, + CornerStart, + CornerDatStart: Integer; + fmtSequenceSeparator: string; + fmtStart, fmtSep, fmtSepOutputLine, + fmtSepLine, fmtEnd, fmtMapSep, fmtTileSep, + fmtTinyTileSep, + fmtTSSep, fmtPalSep, fmtTrans: string; + fmtCornerSep: string; + filepos: Integer; + LastPos: Integer; + + tmpi, tmpj: Integer; + + iCmd, + tmpCmd, + CurCmd: CmdType; + CmdList: string; + CmdOk: Boolean; + sMsg: string; + CurTrans: Boolean; + + // 3.0 + ListCount: Integer; + ListIdx: array of Integer; + ListDataWidth: array of Integer; + ListDataHeight: array of Integer; + ListCodeStart: array of Integer; + ListStr: array of String; + ListCmdRec: array of CommandRec; + tmpCmdRec: CommandRec; + + + + procedure WritePos (s: string); + var + i: Integer; + begin + + if WritingBinFile then + begin + if (s <> '') and (s[1] = #0) and (s[Length (s)] = #0) then + begin + Delete (s, Length (s), 1); + Delete (s, 1, 1); + end; + end + else + for i := 1 to Length (s) do + if s[i] in [#13, #10] then + filepos := 0 + else + Inc (filepos); + + Write (F, s); + end; + + + + + + procedure InitDatVars (Cmd: CmdType); + begin + case Cmd of + + ctTile, + ctTSTile, + ctTile0, + ctUTTile: InitTileVars (Cmd = ctTile0); + + ctTileData: CurTrans := not InitTileDatVars; + + ctTexTileData: CurTrans := not InitTexTileDatVars; + + ctMap: InitMapVars; + ctMapData: InitMapDatVars; + + ctPalette: InitPaletteVars; + ctPaletteData: InitPalDatVars; + + ctCorner: InitCornerVars; + ctCornerData: CurTrans := not InitCornerDatVars; + + ctSequence: InitSeqVars; + ctSequenceData: InitSeqDatVars; + ctSequenceFrame: InitSeqFrameVars; + + ctHEdge: InitHEdgeVars; + ctHEdgeData: CurTrans := not InitHEdgeDatVars; + + ctVEdge: InitVEdgeVars; + ctVEdgeData: CurTrans := not InitVEdgeDatVars; + + ctTileMap: InitTileMapVars; + + ctList: InitListVars (ListStr[ListCount - 1], ListIdx[ListCount - 1], ListCount - 1); + + ctReadTextFile, + ctReadBinFile: InitFileDatVars; + + end; + end; + + + begin { runcode / (generatecode) } + CodeError (0, ''); + Error := FALSE; + + SetLength (VarList, 0); + + SetNumVar ('TileSetCount', Tab.Tabs.Count); + SetNumVar ('TileSetNumber', -1); + + SetStrVar ('ProjectName', ProjectName); + + // new 2.0 + SetStrVar ('OutputDir', OutputPath); + SetStrVar ('CurrentDate', DateToStr (Date)); + SetStrVar ('CurrentTime', TimeToStr (Time)); + SetStrVar ('TSVersion', VERSION_NUMBER); + SetNumVar ('PaletteCount', Length (aaiPal)); + + SetStrVar ('shl', 'SHL'); + SetStrVar ('shr', 'SHR'); + SetStrVar ('if', 'IF'); + SetStrVar ('then', 'THEN'); + SetStrVar ('else', 'ELSE'); + SetStrVar ('not', 'NOT'); + SetStrVar ('equals', 'EQUALS'); + SetStrVar ('above', 'ABOVE'); + SetStrVar ('below', 'BELOW'); + + + with Info do + begin + SetStrVar ('Author', Author.Text); + SetStrVar ('Notes', Notes.Text); + SetStrVar ('Copyright', Copyright.Text); + end; + + + FilePos := 0; + CurPos := 1; + Done := FALSE; + WritingFile := FALSE; + WritingBinFile := FALSE; + FirstLine := FALSE; + WritingMapData := FALSE; + WritingTileData := FALSE; + WritingTexTileData := FALSE; + WritingCornerData := FALSE; + { WritingTinyTileData := FALSE; } + WritingSeqData := FALSE; + WritingSeqFrames := FALSE; + WritingPalData := FALSE; + itab := -1; + TileSetStart := -1; + imap := -1; + MapStart := -1; + idat := -1; + TileStart := -1; + TSTileStart := -1; + { TinyTileStart := -1; } + TileDatStart := -1; + TexTileDatStart := -1; + { TinyTileDatStart := -1; } + itile := -1; + itstile := -1; + { itinytile := -1; } + MapDatStart := -1; + iseq := -1; + SeqStart := -1; + iseqdat := -1; + SeqDatStart := -1; + OutputFileName := ''; + OutputWidth := 256; // 2.5 + SeqLen := -1; + ipal := -1; + PaletteStart := -1; + ipaldat := -1; + PalDatStart := -1; + + itilemap := -1; + icornerdat := -1; + CornerStart := -1; + + ListCount := 0; // 3.0 + + for tmpi := 0 to MAX_COUNTER do + Counters[tmpi] := 0; + + ReadingAhead := FALSE; + + ReadingTextFile := FALSE; + ReadingBinFile := FALSE; + InputFileName := ''; + InputFilePos := 0; + ifile := -1; + + + + StartWithEmptyTile := FALSE; + + SetNumVar ('TRUE', 1); + SetNumVar ('FALSE', 0); + + + + + + CmdList := ''; + for tmpCmd := Low (CmdType) to High (CmdType) do + with Commands[tmpCmd] do + begin + if idx <> nil then + idx^ := -1; + CodeStart := -1; + end; + + + s := ''; + repeat + if s <> #0 then + s := GetTokenSpecial; + if s = '' then + Done := TRUE; + LastPos := CurPos; + t := LookAheadToken; + if (s = #0) and ((t = ';') or (t = '#')) then + begin + s := GetTokenSpecial; + if s = '!' then // ignore options here + begin + s := GetLine; + s := ''; + end; + if s = ';' then + begin + s := GetLine; + s := ''; + end; + if s = '#' then + begin + LastPos := CurPos; + s := UGetToken; + + // commands without #END could be placed here + // + // s := ''; + + if (s <> '') then + for iCmd := Low (CmdType) to High (CmdType) do + if iCmd in SupportedCmds then + with Commands[icmd] do + if s = KeyWord then + begin + if CurCmd <> CmdType (-1) then + Insert (Chr (Ord (CurCmd)), CmdList, 1); + CurCmd := iCmd; + + sMsg := ''; + CmdOk := ReqCmd = []; + for tmpCmd := Low (CmdType) to High (CmdType) do + if tmpCmd in ReqCmd then + begin + if sMsg <> '' then + sMsg := sMsg + ' / '; + sMsg := sMsg + Commands[tmpCmd].KeyWord; + if (Commands[tmpCmd].idx = nil) or (Commands[tmpCmd].idx^ >= 0) then + CmdOk := TRUE; + end; + if not CmdOk then + CodeError (LastPos, 'Only allowed between #' + sMsg + ' and #END ' + sMsg) + else + begin + tmpCmdRec := Commands[CurCmd]; + + sFilename := ''; + sListName := ''; + sBegin := ''; + sSeparator := ''; + sLongLineSeparator := ''; + sNextSeparator := ''; + sEnd := ''; + sTrans := ''; + + for tmpi := 1 to Length (Parameters) do + case Parameters[tmpi] of + 'F': sFilename := GetFilename; // GetString; 3.00 + 'P': begin // list (recursive) + sListName := GetString; + Inc (ListCount); + SetLength (ListIdx, ListCount); + SetLength (ListDataWidth, ListCount); + SetLength (ListDataHeight, ListCount); + SetLength (ListCodeStart, ListCount); + SetLength (ListStr, ListCount); + SetLength (ListCmdRec, ListCount); + ListIdx[ListCount - 1] := -1; + idx := @(ListIdx[ListCount - 1]); + ListDataWidth[ListCount - 1] := DataWidth; + ListDataHeight[ListCount - 1] := DataHeight; + ListCodeStart[ListCount - 1] := CodeStart; + ListStr[ListCount - 1] := sListName; + ListCmdRec[ListCount - 1] := tmpCmdRec; + end; + 'B': sBegin := GetStringOrToken; + 'S': sSeparator := GetStringOrToken; + 'L': if not WritingBinFile then + sLongLineSeparator := GetString; + 'N': sNextSeparator := GetStringOrToken; + 'E': sEnd := GetStringOrToken; + 'T': sTrans := GetStringOrToken; + + end; + + CodeStart := CurPos; + idx^ := 0; + + DataWidth := 0; + DataHeight := 1; + + case CurCmd of + + ctTile: if ValidTileSet then + if TinyTiles then + DataWidth := aFinalTinyTileCount[itab][TinyFlip] + else + DataWidth := aFinalTileCount[itab]; + + ctTile0: if ValidTileSet then + DataWidth := 1; + + ctTSTile: if ValidTSTileSet then + DataWidth := TileTab[itab].tbr.TileCount * GetTinyNH * GetTinyNV; + + ctTileData: if ValidTileSet then + if TinyTiles then + begin + DataWidth := TinyW; + DataHeight := TinyH; + end + else + begin // 2.53 - N parameter is now set + DataWidth := TileTab[itab].tbr.W; + DataHeight := TileTab[itab].tbr.H; + end; + // DataWidth := TileTab[itab].tbr.W * TileTab[itab].tbr.H; + + ctTexTileData: begin + DataWidth := TileTab[itab].tbr.W + 2; + DataHeight := TileTab[itab].tbr.H + 2; + end; + + ctMap: if ValidTileSet then + with TileTab[itab].tbr do + begin + DataWidth := Length (Maps.aMaps); + while (Maps.aMaps[imap].SkipExport = TRUE) do + Inc (imap); + end; + + ctMapData: begin + DataWidth := MapWd; + DataHeight := MapHt; + end; + + ctCorner: DataWidth := aCornerCount[itab]; + + ctCornerData: DataWidth := 4; + + ctSequence: if ValidTileSet then + with TileTab[itab].tbr do + DataWidth := GetTinyNH * GetTinyNV * + Length (Seq.aMaps); + + ctSequenceData: if ValidTileSet then + DataWidth := SeqLen; + + ctSequenceFrame: if ValidTileSet then + DataWidth := SeqFrames; + + ctHEdge: DataWidth := aHEdgeCount[itab]; + + ctHEdgeData: begin + DataWidth := TileTab[itab].tbr.W; + DataHeight := 2; + end; + + ctVEdge: DataWidth := aVEdgeCount[itab]; + + ctVEdgeData: begin + DataWidth := 2; + DataHeight := TileTab[itab].tbr.H; + end; + + ctTileMap: begin + DataWidth := TinyNH; + DataHeight := TinyNV; + end; + + ctPalette: DataWidth := Length (aaiPal); + + ctPaletteData: DataWidth := aiPalSize[ipal]; // Length (aaiPal[ipal]); + + + ctUTTile: if ValidTileSet then + DataWidth := aUTTCount[itab]; + + ctTileBitmap, + ctTSTileBitmap: begin + DataWidth := 1; + DataHeight := 1; + end; + + ctList: DataWidth := GetListLength (sListName); + + ctReadTextFile: if sFilename <> '' then + begin + InputFileName := AdjustFilename (sFilename, OutputPath); + if InputFileName <> '' then + begin + DataWidth := GetTextFileLineCount (InputFileName); + AssignFile (TI, InputFileName); + Reset (TI); + ReadingTextFile := TRUE; + InputFilePos := 0; + end; + end; + + ctReadBinFile: if sFilename <> '' then + begin + InputFileName := AdjustFilename (sFilename, OutputPath); + if InputFileName <> '' then + begin + DataWidth := GetBinFileSize (InputFileName); + AssignFile (FI, InputFileName); + Reset (FI); + ReadingBinFile := TRUE; + InputFilePos := 0; + end; + end; + + end; + + if (idx^ >= DataWidth * DataHeight) or + (DataWidth * DataHeight <= 0) then + begin + FindEnd (s); + + idx^ := -1; + CodeStart := -1; + + if CurCmd = ctList then + begin + Dec (ListCount); + if ListCount > 0 then + begin + Commands[CurCmd] := ListCmdRec[ListCount]; + DataWidth := ListDataWidth[ListCount]; + DataHeight := ListDataHeight[ListCount]; + CodeStart := ListCodeStart[ListCount]; + idx := @(ListIdx[ListCount - 1]); + end + else + idx := nil; + SetLength (ListIdx, ListCount); + SetLength (ListDataWidth, ListCount); + SetLength (ListDataHeight, ListCount); + SetLength (ListCodeStart, ListCount); + SetLength (ListStr, ListCount); + SetLength (ListCmdRec, ListCount); + end; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end + else + InitDatVars (CurCmd); + + end; + if not (Pos ('X', Commands[CurCmd].Parameters) > 0) then + begin + s := ''; + FilePos := 0; + end; + end; + + + if s = 'FILE' then + begin + if WritingFile or WritingBinFile then + CodeError (LastPos, 'Already writing a file') + else + begin + OutputFileName := GetFilename; + + if OutputFileName <> '' then + begin + if (Pos (':', OutputFileName) = 2) or (OutputFileName[1] = '\') then + AssignFile (F, OutputFileName) + else + begin + CreatePath (OutputPath + OutputFileName); // 2.54 bug fix + AssignFile (F, OutputPath + OutputFileName); + end; + ReWrite (F); + WritingFile := TRUE; + FirstLine := TRUE; + end; + end; + s := ''; + end; + + if s = 'BINFILE' then + begin + if WritingFile or WritingBinFile then + CodeError (LastPos, 'Already writing a file') + else + begin + OutputFileName := GetFilename; + if OutputFileName <> '' then + begin + if (Pos (':', OutputFileName) = 2) or (OutputFileName[1] = '\') then + AssignFile (F, OutputFileName) + else + begin + CreatePath (OutputPath + OutputFileName); // 2.54 bug fix + AssignFile (F, OutputPath + OutputFileName); + end; + ReWrite (F); + WritingBinFile := TRUE; + // FirstLine := TRUE; + end; + + DefaultBinFileBits := 8; + tmpi := -1; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + tmpi := StrToInt (s); + end; + if tmpi in [8, 16, 24, 32] then + DefaultBinFileBits := tmpi + else + CodeError (LastPos, 'Allowed values are 8, 16, 24 or 32 bits'); + + end; + s := ''; + end; + + + + (* + // 2.0 + if s = 'PALETTE' then + begin + fmtPalSep := GetString; + PaletteStart := CurPos; + ipal := 0; + + { 2.1 } + if (ipal >= 0) and (Length (aaiPal) > 0) and + (PaletteManager.GetID (ipal) <> '') then + InitPaletteVars + else + FindEnd (s); + s := ''; + end; + // + + // 2.4 + if s = 'CORNER' then + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + fmtCornerSep := GetString; + CornerStart := CurPos; + icorner := 0; + + if not InitCornerVars then + FindEnd (s); + s := ''; + end; + // + *) + + + // 2.2 + if s = 'TINYTILES' then + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + tmpi := -1; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + tmpi := StrToInt (s); + end; + + tmpj := -1; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + tmpj := StrToInt (s); + end; + + if (tmpi <= 0) or (tmpj <= 0) then + CodeError (LastPos, 'Illegal size value(s)') + else + begin + + if ValidTileSet then + SetupTinyTiles (tmpi, tmpj, NOFLIP) + else + begin + TinyW := tmpi; + TinyH := tmpj; + + end; + + if (TinyW <= 0) or (TinyH <= 0) then + FindEnd ('TINYTILES') + else + begin + with TileTab[itab] do + begin + TinyNH := tbr.W div TinyW; + TinyNV := tbr.H div TinyH; + end; + + TinyTiles := TRUE; + + InitTileSetVars; + + end; + end; + s := ''; + end; + + + if s = 'TILESET' then + begin + fmtTSSep := GetStringOrToken; // 2.0 + TileSetStart := CurPos; + itab := 0; + ShowProgress (0, 100); // 2.53 + if GetValidTileSet then + InitTileSetVars + else + FindEnd (s); + s := ''; + end; + + + if s = 'TSTILEBITMAP' then // 2.5 + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + OutputFileName := GetFilename; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + OutputWidth := StrToInt (s); + end; + + s := ''; + end; + + + if s = 'TILEBITMAP' then + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + OutputFileName := GetFilename; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + WidenBitmap (StrToInt (s)); + InitTileSetVars; + end; + + s := ''; + end; + + + if (s = ';') or (s = '#') then + begin + if WritingFile then + begin + if not FirstLine then + WriteLn (F); + FirstLine := FALSE; + Write (F, s); + end; + s := ''; + end; + + + + if s = 'END' then + begin + s := USGetToken; + + + // 2.2 + if s = 'TINYTILES' then + begin + TinyTiles := FALSE; + + InitTileSetVars; + + TinyW := -1; + TinyH := -1; + s := ''; + end; + + + if s = 'FILE' then + begin + if not WritingFile then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + CloseFile (F); + WritingFile := FALSE; + FirstLine := FALSE; + OutputFileName := ''; + end; + s := ''; + end; + + if s = 'BINFILE' then + begin + if not WritingBinFile then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + CloseFile (F); + WritingBinFile := FALSE; + // FirstLine := FALSE; + OutputFileName := ''; + end; + s := ''; + end; + + + if (CurCmd in SupportedCmds) and (s <> '') then + with Commands[CurCmd] do + begin + if (s <> KeyWord) or (idx^ < 0) or (CodeStart < 0) then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + + // next ... + case CurCmd of + ctMap: + with TileTab[itab].tbr do + begin + Inc (imap); + + while (imap <= Length (Maps.aMaps) - 1) and // 2.43 bug fix (last map was always exported) + (Maps.aMaps[imap].SkipExport = TRUE) do + Inc (imap); + + if imap < Length (Maps.aMaps) then + if WritingFile or WritingBinFile then + WritePos (sSeparator); + end; + + else + if WritingFile or WritingBinFile then + begin + if idx^ mod DataWidth = DataWidth - 1 then + begin + if idx^ = DataWidth * DataHeight - 1 then + WritePos (sEnd) + else + if Pos ('N', Parameters) > 0 then + WritePos (sNextSeparator) + else + WritePos (sSeparator); + end + else + if (FilePos > LONG_LINE) and (Pos ('L', Parameters) > 0) then + WritePos (sLongLineSeparator) + else + WritePos (sSeparator); + end; + + Inc (idx^); + + end; + + if not (Pos ('X', Commands[CurCmd].Parameters) > 0) then + begin + if (idx^ < DataWidth * DataHeight) then + begin + CurPos := CodeStart; + + InitDatVars (CurCmd); + + end + else + begin + idx^ := -1; + CodeStart := -1; + + // finally ... + case CurCmd of + ctList: + begin + Dec (ListCount); + if ListCount > 0 then + begin + Commands[CurCmd] := ListCmdRec[ListCount]; + DataWidth := ListDataWidth[ListCount]; + DataHeight := ListDataHeight[ListCount]; + CodeStart := ListCodeStart[ListCount]; + idx := @(ListIdx[ListCount - 1]); + end + else + idx := nil; + SetLength (ListIdx, ListCount); + SetLength (ListDataWidth, ListCount); + SetLength (ListDataHeight, ListCount); + SetLength (ListCodeStart, ListCount); + SetLength (ListStr, ListCount); + SetLength (ListCmdRec, ListCount); + end; + + ctReadTextFile: + begin + CloseFile (TI); + ReadingTextFile := FALSE; + InputFileName := ''; + end; + ctReadBinFile: + begin + CloseFile (FI); + ReadingBinFile := FALSE; + InputFileName := ''; + end; + + end; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end; + end; + + end; + if not (Pos ('X', Commands[CurCmd].Parameters) > 0) then + s := ''; + end; + + + + if s = 'TILESET' then + begin + if TileSetStart = -1 then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + Inc (itab); + ShowProgress (0, 100); // 2.53 + if GetValidTileSet then + begin + if WritingFile or WritingBinFile then + WritePos (fmtTSSep); // 2.0 + CurPos := TileSetStart; + InitTileSetVars; + end + else + begin + itab := -1; + SetNumVar ('TileSetNumber', itab); + TileSetStart := -1; + + if (ipal <> -1) and (PaletteStart = -1) then // 2.0 + ipal := -1; + end; + end; + s := ''; + end; + + + if s = 'TSTILEBITMAP' then // 2.5 + begin + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + if OutputFileName <> '' then + with TileTab[itab] do + begin + if not ((Pos (':', OutputFileName) = 2) or // 2.54 bug fix + (OutputFileName[1] = '\')) then + begin + OutputFilename := OutputPath + OutputFileName; + CreatePath (OutputFilename); + end; + + if itstile >= 0 then // 2.54 + begin + idat := 0; + DataW := TileTab[itab].tbr.W; + DataH := TileTab[itab].tbr.H; + bmpCurTile.Width := DataW; + bmpCurTile.Height := DataH; + while idat < DataW * DataH do + begin + CurTrans := not InitTileDatVars; + if CurTrans then + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := TRANS_COLOR + else + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := CurRGB; + Inc (idat); + end; + idat := -1; + bmpCurTile.PixelFormat := pfOutput; + + while (OutputFilename <> '') and (OutputFilename[Length (OutputFilename)] in [' ', #0]) do + Delete (OutputFilename, Length (OutputFilename), 1); + if UpperCase (ExtractFileExt (OutputFilename)) = '.PNG' then + WriteBitmapToPngFile ({OutputPath +} OutputFilename, bmpCurTile, TRANS_COLOR) + else + begin + bmpCurTile.SaveToFile ({OutputPath +} OutputFileName); + {$IFDEF PATCHBMP} + PatchBMPFile ({OutputPath +} OutputFileName); + {$ENDIF} + end; + + end + else + + WriteTileBitmap ({OutputPath +} OutputFileName, + OutputWidth, + TRANS_COLOR, + 0, { border color } + 0, 0, 0, 0, { border w/h / edge w/h } + tbr, + ProgressBar, + FALSE, { bottom right transparent } + FALSE, { store bounds } + 1 { = pf24bit } + ); + + OutputFileName := ''; + + + + + with Commands[CurCmd] do + begin + idx^ := -1; + CodeStart := -1; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end; + + + + end; + s := ''; + end; + + + if s = 'TILEBITMAP' then + begin + if itab = -1 then // 2.5 + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + + if OutputFileName <> '' then + begin + + if itile >= 0 then // 2.54 + begin + idat := 0; + DataW := TileTab[itab].tbr.W; + DataH := TileTab[itab].tbr.H; + bmpCurTile.Width := DataW; + bmpCurTile.Height := DataH; + while idat < DataW * DataH do + begin + CurTrans := not InitTileDatVars; + if CurTrans then + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := TRANS_COLOR + else + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := CurRGB; + Inc (idat); + end; + idat := -1; + + + if not ((Pos (':', OutputFileName) = 2) or // 2.54 bug fix + (OutputFileName[1] = '\')) then + begin + OutputFilename := OutputPath + OutputFileName; + CreatePath (OutputFilename); + end; + + + bmpCurTile.PixelFormat := pfOutput; + while (OutputFilename <> '') and (OutputFilename[Length (OutputFilename)] in [' ', #0]) do + Delete (OutputFilename, Length (OutputFilename), 1); + if UpperCase (ExtractFileExt (OutputFilename)) = '.PNG' then + WriteBitmapToPngFile ({OutputPath +} OutputFilename, bmpCurTile, TRANS_COLOR) + else + begin + bmpCurTile.SaveToFile ({OutputPath +} OutputFileName); + {$IFDEF PATCHBMP} + PatchBMPFile ({OutputPath +} OutputFileName); + {$ENDIF} + end; + end + else + begin { itile = 0, write complete bitmap } + + if not ((Pos (':', OutputFileName) = 2) or // 2.55 bug fix + (OutputFileName[1] = '\')) then + begin + OutputFilename := OutputPath + OutputFileName; + CreatePath (OutputFilename); + end; + + + if bmpFinal[itab].Height > 0 then + begin + CreatePath ({OutputPath +} OutputFileName); + bmpFinal[itab].PixelFormat := pfOutput; + while (OutputFilename <> '') and (OutputFilename[Length (OutputFilename)] in [' ', #0]) do + Delete (OutputFilename, Length (OutputFilename), 1); + if UpperCase (ExtractFileExt (OutputFilename)) = '.PNG' then + WriteBitmapToPngFile ({OutputPath +} OutputFilename, bmpFinal[itab], TRANS_COLOR) + else + begin + bmpFinal[itab].SaveToFile ({OutputPath +} OutputFileName); + {$IFDEF PATCHBMP} + PatchBMPFile ({OutputPath +} OutputFileName); + {$ENDIF} + end; + end; + + end; + OutputFileName := ''; + + + with Commands[CurCmd] do + begin + idx^ := -1; + CodeStart := -1; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end; + + + end; + s := ''; + end; + + + + end; + end; + if s <> '' then + CodeError (LastPos, 'Syntax error'); + s := ''; + end + +{ } + + else + if CurCmd in SupportedCmds then + with Commands[CurCmd] do + begin + + repeat + if WritingFile or WritingBinFile then + if s <> #0 then + begin + if idx^ = 0 then + WritePos (sBegin); + + if CurTrans and (sTrans <> '') then + WritePos (sTrans) + else + WritePos (s); + + end + else + if not WritingBinFile then + if NewLine then + begin + if not FirstLine then + WritePos (#13#10); + FirstLine := FALSE; + end; + + s := GetTokenSpecial; + t := LookAheadToken; + while (s <> #0) and (t <> #0) and (t <> '') do + begin + if WritingBinFile then + begin + WritePos (s); + s := ''; + end; + s := s + GetTokenSpecial; + t := LookAheadToken; + end; + until (s = #0) or (s = '') or Done or Error; + + end + +{ } + + else + if WritingSeqData or WritingSeqFrames or WritingPalData then + begin + repeat + if WritingFile or WritingBinFile then + if s <> #0 then + begin + if (WritingSeqData and (iseqdat = 0)) or + (WritingSeqFrames and (iseqdat = 0)) or + (WritingPalData and (ipaldat = 0)) then + WritePos (fmtStart); + WritePos (s); + if (WritingSeqData and (iseqdat = SeqLen - 1)) or + (WritingSeqFrames and (iseqdat = SeqFrames - 1)) or + (WritingPalData and (ipaldat = { Length (aaiPal[ipal]) } aiPalSize[ipal] - 1)) then // 2.41 + WritePos (fmtEnd) + else + WritePos (fmtSep); + end; + s := GetTokenSpecial; + t := LookAheadToken; + while (s <> #0) and (t <> #0) and (t <> '') do + begin + s := s + GetTokenSpecial; + t := LookAheadToken; + end; + until (s = #0) or (s = '') or Done or Error; + end + else + if WritingMapData + or WritingTileData + or WritingTexTileData + or WritingCornerData + { or WritingTinyTileData } then + begin + itmpdat := idat; + if WritingMapData then + begin + tmpW := MapWd; + tmpH := MapHt; + end; + if WritingTileData then + if TinyTiles then + begin + tmpW := TinyW; + tmpH := TinyH; + end + else + begin + tmpW := TileTab[itab].tbr.W; + tmpH := TileTab[itab].tbr.H; + end; + if WritingTexTileData then + begin + tmpW := TileTab[itab].tbr.W + 2; + tmpH := TileTab[itab].tbr.H + 2; + end; + if WritingCornerData then + begin + tmpW := 4; + tmpH := 1; + itmpdat := icornerdat; + end; + + repeat + if WritingFile or WritingBinFile then + if s <> #0 then + begin + if itmpdat = 0 then + WritePos (fmtStart); + + if WritingTileData or WritingTexTileData or WritingCornerData then + begin + if TransReplace = '' then + WritePos (s) + else + if TransReplace <> #0 then + begin + WritePos (TransReplace); + TransReplace := #0; + end; + end + else + WritePos (s); + + if itmpdat mod tmpW = tmpW - 1 then + if itmpdat = tmpW * tmpH - 1 then + WritePos (fmtEnd) + else + WritePos (fmtSepLine) + else + if FilePos > LONG_LINE then + WritePos (fmtSepOutputLine) + else + WritePos (fmtSep); + + end; + + s := GetTokenSpecial; + t := LookAheadToken; + while (s <> #0) and (t <> #0) and (t <> '') do + begin + s := s + GetTokenSpecial; + t := LookAheadToken; + end; + until (s = #0) or (s = '') or Done or Error; + end + else + begin + + repeat + if WritingFile then + begin + if s = #0 then + begin + if not FirstLine then + WriteLn (F); + end + else + Write (F, s); + FirstLine := FALSE; + end; + + if WritingBinFile then + if s <> #0 then + WritePos (s); + + s := GetTokenSpecial; + until (s = #0) or (s = '') or Done or Error; + + end; + + until Done or Error; + + + if WritingFile or WritingBinFile then + CloseFile (F); + + // for itab := 0 to Tab.Tabs.Count - 1 do + + if not Error then + ErrorMsg := ''; + + SetLength (VarList, 0); + + + RunCode := ErrorMsg; + end; + + + procedure ReadCodeOptions (lines: TStrings); + var + i: Integer; + s: string; + begin + + for i := 0 to lines.Count - 1 do + begin + s := UpCaseStr (Trim(lines.Strings[i])); + if (s <> '') then + begin + if (s[1] = '!') then + begin + Delete (s, 1, 1); + + + + if (s = 'STARTWITHEMPTYTILE') then + StartWithEmptyTile := TRUE; + + + end; + end; + end; + + end; + + + +{ TMainForm.Generate1Click } + + var + i, j, k: Integer; + x, y: Integer; + mcr: MapCellRec; + m, u, r: Boolean; + found, diff: Boolean; + N: Integer; + rr, gg, bb: Integer; + tr, tg, tb, ta: Integer; + ii, jj, kk: Integer; + ErrMsg: string; + corner: Integer; + +begin + if CodeGen.LastDef = '' then + begin + MessageDlg ('Please select a code generation definition first.', + mtInformation, [mbOk], 0); + Exit; + end; + + CodeGen.ProjectDir := FilePath (FileName); // 2.5 + code := CodeGen.GetCodeString; + + + if code = '' then + begin + MessageDlg ('Cannot read code generation definition file (' + + CodeGen.LastDef + ').', mtError, [mbOk], 0); + Exit; + end; + + + ReadCodeOptions (CodeGen.Memo.Lines); + + + { + ShowBackLayer.Checked := TRUE; + ShowMidLayer.Checked := TRUE; + ShowFrontLayer.Checked := TRUE; + } + + ProgressPanel.Visible := TRUE; + with ProgressBar do + begin + Min := 0; + Max := 100 * Tab.Tabs.Count; + Position := 0; + end; + + + if aaN < 2 then + aaN := 1; + aa := (aaN >= 2); + aaX := aaN; + aaY := aaN; + + + + SetLength (aMCR, Tab.Tabs.Count); + SetLength (aFinalRef, Tab.Tabs.Count); + SetLength (bmpFinal, Tab.Tabs.Count); + SetLength (bmpAlpha, Tab.Tabs.Count); + SetLength (aFinalTileCount, Tab.Tabs.Count); + SetLength (TransX, Tab.Tabs.Count); + SetLength (TransY, Tab.Tabs.Count); + + SetLength (aFinalTinyTileCount, Tab.Tabs.Count); + SetLength (aFinalTinyTiles, Tab.Tabs.Count); + SetLength (aFinalTinyRef, Tab.Tabs.Count); + TinyW := -1; + TinyH := -1; + TinyFlip := NOFLIP; + TinyTiles := FALSE; + + // 2.4 + TexTiles := { (Pos (#0'#TEXTILEBITMAP', UpCaseStr (code)) > 0) or } + (Pos (#0'#TEXTILEDATA', UpCaseStr (code)) > 0) or + (Pos (#0'#CORNER', UpCaseStr (code)) > 0) or + (Pos (#0'#HEDGE', UpCaseStr (code)) > 0) or + (Pos (#0'#VEDGE', UpCaseStr (code)) > 0); + // 2.5 + UTT := TexTiles and (Pos (#0'#UNIQUETEXTILE', UpCaseStr (code)) > 0); + + + SetLength (aTransTile, Tab.Tabs.Count); + + if TexTiles then + begin + SetLength (bmpTexTiles, Tab.Tabs.Count); + SetLength (bmpTexAlpha, Tab.Tabs.Count); + SetLength (aMCRSur, Tab.Tabs.Count); + SetLength (aSameAs, Tab.Tabs.Count); + SetLength (aTrans, Tab.Tabs.Count); + SetLength (Corners, Tab.Tabs.Count); + SetLength (HEdges, Tab.Tabs.Count); + SetLength (VEdges, Tab.Tabs.Count); + SetLength (aCornerCount, Tab.Tabs.Count); + SetLength (aHEdgeCount, Tab.Tabs.Count); + SetLength (aVEdgeCount, Tab.Tabs.Count); + + if UTT then + begin + SetLength (aUTTRef, Tab.Tabs.Count); + SetLength (aUTTIndex, tab.Tabs.Count); + SetLength (aUTTCount, Tab.Tabs.Count); + end; + end; + + + + + for itab := 0 to Tab.Tabs.Count - 1 do + with TileTab[itab].tbr do + begin + LastW := W; + LastH := H; + end; + + + bmpCurTile := TBitmap.Create; + SetStretchBltMode(bmpCurTile.Canvas.Handle, HALFTONE); + bmpCurTile.PixelFormat := pf24bit; + bmpCurTile.Canvas.Brush.Color := TRANS_COLOR; + + for itab := 0 to Tab.Tabs.Count - 1 do + begin + ShowProgress (0, 100); + + with TileTab[itab] do + begin + + bmp1.Width := tbr.W; + bmp1.Height := tbr.H; + ResizeBitmap (bmp1); + + bmp2.Width := tbr.W; + bmp2.Height := tbr.H; + ResizeBitmap (bmp2); + + bmpFinal[itab] := TBitmap.Create; + SetStretchBltMode(bmpFinal[itab].Canvas.Handle, HALFTONE); + bmpFinal[itab].PixelFormat := pf24bit; + bmpFinal[itab].Width := tbr.W; + bmpFinal[itab].Canvas.Brush.Color := TRANS_COLOR; + + SetLength (aMCR[itab], 0); + N := 0; + + // 2.4 + if TexTiles then + begin + bmpTexTiles[itab] := TBitmap.Create; + SetStretchBltMode(bmpTexTiles[itab].Canvas.Handle, HALFTONE); + bmpTexTiles[itab].PixelFormat := pf24bit; + bmpTexTiles[itab].Width := tbr.W + 2; + bmpTexTiles[itab].Canvas.Brush.Color := TRANS_COLOR; + end; + + // make a collection of all unique MCR's + + with mcr do + begin + Back := -1; + Mid := -1; + Front := -1; + end; + AddMCR (mcr); + + with tbr.Maps do + for i := 0 to Length (aMaps) - 1 do + AddMCRs (aMaps[i].map); + + with tbr.Seq do + for i := 0 to Length (aMaps) - 1 do + AddMCRs (aMaps[i].map); + + SetLength (aFinalRef[itab], Length (aMCR[itab])); + + + // create tile bitmap with unique tiles + + for i := 0 to Length (aMCR[itab]) - 1 do + begin + mcr := aMCR[itab][i]; + FillBitmap (bmp2, TRANS_COLOR); + + with mcr do + begin + if mcr.Back <> -1 then + DrawTile (itab, mcr.Back, bmp1, m, u, r, bmp2); + if mcr.Mid <> -1 then + DrawTile (itab, mcr.Mid, bmp1, m, u, r, bmp2); + if mcr.Front <> -1 then + DrawTile (itab, mcr.Front, bmp1, m, u, r, bmp2); + end; + + found := FALSE; + for j := 0 to N - 1 do + if not found then + begin + diff := FALSE; + for y := 0 to tbr.H - 1 do + if not diff then + for x := 0 to tbr.W - 1 do + if not diff then + if bmp2.Canvas.Pixels[x, y] <> + bmpFinal[itab].Canvas.Pixels[x, y + j * tbr.H] then + diff := TRUE; + if not diff then + begin + aFinalRef[itab][i] := j; + found := TRUE; + end; + end; + +{$IFNDEF PATCHBMP} + { work around for SaveToFile BMP header error with pf24bit } + bmpFinal[itab].PixelFormat := pfFinal; +{$ENDIF} + + if not found then + begin + Inc (N); + + bmpFinal[itab].Height := N * tbr.H; + with tbr do + bmpFinal[itab].Canvas.CopyRect + (MakeRect (0, (N - 1) * H, W, H), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0, W, H)); + aFinalRef[itab][i] := N - 1; + end; + end; + + + // scale down bmpFinal bitmap for anti-aliasing + if aa then + begin + bmpAlpha[itab] := TBitmap.Create; + bmpAlpha[itab].PixelFormat := pf8bit; + bmpAlpha[itab].Width := tbr.W div aaX; + bmpAlpha[itab].Height := N * tbr.H div aaY; + + with tbr, bmpFinal[itab] do + begin + for k := 0 to N - 1 do + for j := 0 to (H {+ aaY - 1}) div aaY - 1 do + for i := 0 to (W {+ aaX - 1}) div aaX - 1 do + begin + tr := 0; tg := 0; tb := 0; ta := 0; + + kk := 0; + for jj := 0 to aaY - 1 do + for ii := 0 to aaX - 1 do + if (j * aaY + jj < H) and (i * aaX + ii < W) then + begin + GetRGB (Canvas.Pixels[i * aaX + ii, k * H + j * aaY + jj], rr, gg, bb); + if RGB (rr, gg, bb) <> TRANS_COLOR then + begin + tr := tr + rr; + tg := tg + gg; + tb := tb + bb; + ta := ta + 255; + Inc (kk); + end; + end; + + + if ta = 0 then + Canvas.Pixels[i, j + k * ((H {+ aaY - 1}) div aaY)] := TRANS_COLOR + else + Canvas.Pixels[i, j + k * ((H {+ aaY - 1}) div aaY)] := + RGB (tr div kk, tg div kk, tb div kk); + + bmpAlpha[itab].Canvas.Pixels[i, j + k * ((H {+ aaY - 1}) div aaY)] := + ta div (aaX * aaY); + end; + + W := (W {+ aaX - 1}) div aaX; + H := (H {+ aaY - 1}) div aaY; + + Width := Width div aaX; + Height := Height div aaY; + end; + end; + + + // find a transparent pixel, or add transparent tile to the end + TransX[itab] := -1; + TransY[itab] := -1; + + with tbr, bmpFinal[itab] do + if Height > 0 then + begin + if StartWithEmptyTile then + begin + TransX[itab] := 0; + TransY[itab] := 0; + end + else + begin + for i := 1 to N - 1 do + begin + Canvas.CopyRect (MakeRect (0, (i - 1) * H, W, H), + Canvas, MakeRect (0, i * H, W, H)); + if aa then + with bmpAlpha[itab] do + Canvas.CopyRect (MakeRect (0, (i - 1) * H, W, H), + Canvas, MakeRect (0, i * H, W, H)); + end; + for j := 0 to Height - 1 do + for i := 0 to W - 1 do + if Canvas.Pixels[i, j] = TRANS_COLOR then + begin + TransX[itab] := i; + TransY[itab] := j; + end; + if TransX[itab] <> -1 then + begin + aTransTile[itab] := 0; + Height := Height - H; + end + else + begin + for j := 0 to H - 1 do + for i := 0 to W - 1 do + Canvas.Pixels[i, Height - 1 - j] := TRANS_COLOR; + aTransTile[itab] := 1; + end; + end; + + + // aFinalTileCount[itab] := N; + aFinalTileCount[itab] := bmpFinal[itab].Height div H; // 2.34 + + // 2.4 + if TexTiles then + begin + i := aFinalTileCount[itab]; + bmpTexTiles[itab].Width := W + 2; + bmpTexTiles[itab].Height := i * (H + 2); + for j := 0 to i - 1 do + bmpTexTiles[itab].Canvas.CopyRect (MakeRect (1, j * (H + 2) + 1, W, H), + Canvas, MakeRect (0, j * H, W, H)); + + if aa then + begin + bmpTexAlpha[itab] := TBitmap.Create; + bmpTexAlpha[itab].PixelFormat := pf8bit; + bmpTexAlpha[itab].Width := W + 2; + bmpTexAlpha[itab].Height := i * (H + 2); + with bmpAlpha[itab] do + for j := 0 to i - 1 do + bmpTexAlpha[itab].Canvas.CopyRect (MakeRect (1, j * (H + 2) + 1, W, H), + Canvas, MakeRect (0, j * H, W, H)); + end; + + end; + end; + + + if TexTiles then + begin + + SetLength (aMCRSur[itab], Length (aFinalRef[itab])); + SetLength (aSameAs[itab], Length (aFinalRef[itab])); + SetLength (aTrans[itab], Length (aFinalRef[itab])); + SetLength (Corners[itab], 0); + SetLength (HEdges[itab], 0); + SetLength (VEdges[itab], 0); + + if UTT then + begin + SetLength (aUTTRef[itab], Length (aFinalRef[itab])); + SetLength (aUTTIndex[itab], Length (aFinalRef[itab])); + end; + + { ... edges and corners ... } + + SetEdgeRects (tbr.W, tbr.H); + + with tbr.Maps do + for i := 0 to Length (aMaps) - 1 do + CreateEdgeData (aMaps[i].map, tbr.Seq); + + FindSameEdges; + GetEdgeColors; + + for j := 0 to Length (aMCRSur[itab]) - 1 do + begin + for i := 0 to 7 do + if EdgeToCorner[i] = -1 then + begin + + k := GetMostSurTile (itab, j, i); + + + if k > -1 then + with tbr do + bmpTexTiles[itab].Canvas.CopyRect + (AddRect (EdgeDst[i], MakeRect (0, (j - 1) * (H + 2), 0, 0)), + bmpTexTiles[itab].Canvas, + AddRect (EdgeSrc[i], MakeRect (0, (k - 1) * (H + 2), 0, 0))); + + end; + + for i := 0 to 7 do + if EdgeToCorner[i] <> -1 then + begin + corner := 3 - EdgeToCorner[i]; + x := TileCornerX[corner]; + y := TileCornerY[corner] + (j - 1) * (H + 2); + with bmpTexTiles[itab].Canvas do + begin + TmpCorner[0] := Pixels[x, y]; + TmpCorner[1] := Pixels[x + 1, y]; + TmpCorner[2] := Pixels[x, y + 1]; + TmpCorner[3] := Pixels[x + 1, y + 1]; + end; + TmpCorner[corner] := -1; + + k := GetBestCorner (j, EdgeToCorner[i], TmpCorner); + + if k <> -1 then + begin + TmpCorner[corner] := Corners[itab][k].Colors[corner]; + with tbr do + bmpTexTiles[itab].Canvas.Pixels[EdgeDst[i].Left, + (j - 1) * (H + 2) + EdgeDst[i].Top] := + TmpCorner[corner]; + end; + + CreateCornerData (j, i, k, TmpCorner); + + end; + end; + + aCornerCount[itab] := NumberCornerData; + SortMCRSur; + + CreateHVEdgeData; + + + + // 2.5 - uniquetextiles + if UTT then + begin + aUTTCount[itab] := aFinalTileCount[itab]; + + for i := 0 to aUTTCount[itab] - 1 do + aUTTIndex[itab][i] := i + 1; + + with tbr.Maps do + for i := 0 to Length (aMaps) - 1 do + CreateUTTData (aMaps[i].map, tbr.Seq); + end; + + + + + + // asm nop end; + + end; + + + { + bmpFinal[itab].PixelFormat := pf24bit; + if N > 0 then + bmpFinal[itab].SaveToFile ('test' + IntToStr (itab) + '.bmp'); + if TexTiles then + if N > 0 then + bmpTexTiles[itab].SaveToFile ('tex' + IntToStr (itab) + '.bmp'); + } + + //// bmpFinal[itab].SaveToFile('bmpfinal' + chr(ord('1')+itab) + '.bmp'); + + + end; + end; + + + // generate the code + + ErrMsg := RunCode; + + + for itab := 0 to Tab.Tabs.Count - 1 do + with TileTab[itab].tbr do + begin + W := LastW; + H := LastH; + end; + + + if ReadParamCMD <> 'F10' then + begin + if ErrMsg <> '' then + ShowMessage (ErrMsg) + else + begin + with ProgressBar do + Position := Max; + // mgarcia removed CMDLINE-OPS + ShowMessage ('Code generated successfully'); + end; + end; + end; + + + + + // clean up and release memory + + SetLength (aFinalTinyTileCount, 0); + SetLength (aFinalTileCount, 0); + + for itab := 0 to Tab.Tabs.Count - 1 do + begin + SetLength (aFinalTinyTiles[itab][NOFLIP], 0); + SetLength (aFinalTinyTiles[itab][HFLIP], 0); + SetLength (aFinalTinyTiles[itab][VFLIP], 0); + SetLength (aFinalTinyTiles[itab][HVFLIP], 0); + + SetLength (aFinalTinyRef[itab], 0); + SetLength (aMCR[itab], 0); + SetLength (aFinalRef[itab], 0); + bmpFinal[itab].Free; + if aa then + bmpAlpha[itab].Free; + + // 2.4 + if TexTiles then + begin + if UTT then + SetLength (aUTTRef[itab], 0); + + SetLength (Corners[itab], 0); + SetLength (HEdges[itab], 0); + SetLength (VEdges[itab], 0); + bmpTexTiles[itab].Free; + if aa then + bmpTexAlpha[itab].Free; + end; + end; + + bmpCurTile.Free; // 2.54 + + + SetLength (aTransTile, 0); + + if TexTiles then + begin + if UTT then + begin + SetLength (aUTTRef, 0); + SetLength (aUTTIndex, 0); + SetLength (aUTTCount, 0); + end; + + SetLength (aCornerCount, 0); + SetLength (aHEdgeCount, 0); + SetLength (aVEdgeCount, 0); + SetLength (Corners, 0); + SetLength (HEdges, 0); + SetLength (VEdges, 0); + SetLength (aTrans, 0); + SetLength (aSameAs, 0); + SetLength (aMCRSur, 0); + SetLength (bmpTexTiles, 0); + SetLength (bmpTexAlpha, 0); + end; + + SetLength (aFinalTinyTiles, 0); + SetLength (aFinalTinyRef, 0); + SetLength (aFinalRef, 0); + SetLength (aMCR, 0 ); + + SetLength (bmpFinal, 0); + SetLength (bmpAlpha, 0); + + SetLength (TransX, 0); + SetLength (TransY, 0); + + bmp2.Width := W; + bmp2.Height := H; + ResizeBitmap (bmp2); + bmp1.Width := W; + bmp1.Height := H; + ResizeBitmap (bmp1); + + ProgressPanel.Visible := FALSE; + Modified := TRUE; + +end; + +procedure TMainForm.CodeGenerationSettings1Click(Sender: TObject); + var + s: string; +begin + s := CodeGen.LastDef; + CodeGen.ProjectDir := FilePath (FileName); + CodeGen.ShowModal; + if CodeGen.LastDef <> s then + Modified := TRUE; +end; + + +procedure TMainForm.SelectOutputDirectory1Click(Sender: TObject); + var + f, s: string; + rel: Boolean; +begin + + f := FileName; + if f <> '' then + while (Pos ('\', f) > 0) and (f[Length (f)] <> '\') do + Delete (f, Length (f), 1); + + s := OutputPath; + if (s <> '') and (s[Length (s)] = '\') then + Delete (s, Length (s), 1); + Rel := True; + if s <> '' then + begin + s := s + '\'; + if s[1] = '\' then + Rel := FALSE; + if (Length (s) >= 3) and (s[2] = ':') then + Rel := FALSE; + end; + if Rel then + if f <> '' then + s := f + s; + + try + OutputDir.DirectoryListBox.Directory := s; + except + OutputPath := ''; + OutputDir.DirectoryListBox.Directory := ''; + end; + + OutputDir.ShowModal; + if OutputDir.Result then + begin + s := OutputDir.DirectoryListBox.Directory; + + if Copy (s, 1, Length (f)) = f then + Delete (s, 1, Length (f)); + + OutputPath := s; + if OutputPath <> '' then + if OutputPath[Length (OutputPath)] <> '\' then + OutputPath := OutputPath + '\'; + Modified := TRUE; + + SelectOutputDirectory1.Checked := TRUE; + OutputtoProjectDirectory1.Checked := FALSE; + end; +end; + +procedure TMainForm.ReplaceColors1Click(Sender: TObject); + var + i, j, k, l, m, n, o: Integer; + r, g, b, rr, gg, bb, r1, g1, b1, r2, g2, b2: Integer; + c: Integer; + + function verh (m1, m2, m, n1, n2: Integer): Integer; + begin + if m1 = m2 then + verh := n1 + else + verh := n1 + (n2 - n1) * (m - m1) div (m2 - m1); + end; + +begin + GetTileArea; + + // 2.54 - update: use current color pattern + if SplitColorPattern1.Checked then + with Bmp.Canvas do + begin + SaveUndo ('Replace Colors'); + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + begin + c := Pixels[TileAreaX + i, TileAreaY + j]; + if c <> TRANS_COLOR then + begin + + for k := FromToFirst to FromToLast do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + for k := FromToLast downto FromToFirst do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + + c := ColorMatch (c); + + for k := FromToFirst to FromToLast do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + for k := FromToLast downto FromToFirst do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + + Pixels[TileAreaX + i, TileAreaY + j] := c; + end; + end; + + AddColorPattern1Click(Sender); + UpdateBmp (TRUE); + Modified := TRUE; + Exit; + end; + + m := -1; + n := 0; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + with Bmp.Canvas do + begin + o := 0; + c := Pixels[TileAreaX + i, TileAreaY + j]; + if c <> TRANS_COLOR then + begin + c := ColorMatch (c); + for k := 0 to Length (FromToSave) - 1 do + for l := 0 to MAX_FROM_TO - 1 do + if c = FromToSave[k].FT[l] then + begin + Inc (o); + if o > n then + begin + m := k; + n := o; + end; + end; + end; + end; + if m < 0 then + Exit; + SaveUndo ('Replace Colors'); + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + with Bmp.Canvas do + begin + // o := 0; + c := Pixels[TileAreaX + i, TileAreaY + j]; + if c <> TRANS_COLOR then + begin + { + c := ColorMatch (c); + for l := 0 to MAX_FROM_TO - 1 do + if c = FromToSave[m].FT[l] then + begin + Pixels[BORDER_W + i, BORDER_H + j] := FromToList[l]; + Inc (o); + end; + if o = 0 then } + begin + GetRGB (c, R, G, B); + + r1 := 0; + g1 := 0; + b1 := 0; + for l := 0 to MAX_FROM_TO - 1 do + begin + GetRGB (FromToSave[m].FT[l], rr, gg, bb); + if rr <= r then + r1 := l; + if gg <= g then + g1 := l; + if bb <= b then + b1 := l; + end; + + r2 := MAX_FROM_TO - 1; + g2 := MAX_FROM_TO - 1; + b2 := MAX_FROM_TO - 1; + for l := MAX_FROM_TO - 1 downto 0 do + begin + GetRGB (FromToSave[m].FT[l], rr, gg, bb); + if rr >= r then + r2 := l; + if gg >= g then + g2 := l; + if bb >= b then + b2 := l; + end; + + r := verh (FromToSave[m].EXFT[r1, 0], + FromToSave[m].EXFT[r2, 0], + r, + ExFromToList[r1, 0], + ExFromToList[r2, 0]); + g := verh (FromToSave[m].EXFT[g1, 1], + FromToSave[m].EXFT[g2, 1], + g, + ExFromToList[g1, 1], + ExFromToList[g2, 1]); + b := verh (FromToSave[m].EXFT[b1, 2], + FromToSave[m].EXFT[b2, 2], + b, + ExFromToList[b1, 2], + ExFromToList[b2, 2]); + r := LimitRGB (r); + g := LimitRGB (g); + b := LimitRGB (b); + + r := ColorMatch (r); + g := ColorMatch (g); + b := ColorMatch (b); + + Pixels[TileAreaX + i, TileAreaY + j] := ColorMatch (RGB (r, g, b)); + end; + end; + end; + + AddColorPattern1Click(Sender); + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.MapScrollFunction1Click(Sender: TObject); +begin + if MapTab.TabIndex > -1 then + with TileTab[Tab.TabIndex].tbr.Maps do + begin + with aMaps[CurMap] do + begin + if fx = '' then + MapScroll.X.Text := 'x' + else + MapScroll.X.Text := fx; + if fy = '' then + MapScroll.Y.Text := 'y' + else + MapScroll.Y.Text := fy; + end; + MapScroll.ShowModal; + if MapScroll.Result then + begin + aMaps[CurMap].fx := MapScroll.X.Text; + aMaps[CurMap].fy := MapScroll.Y.Text; + Modified := TRUE; + end; + end; +end; + +function BlackWhite (rgb: Integer): Integer; + var + R, G, B: Integer; +begin + GetRGB (rgb, R, G, B); + if R + G + B >= 3 * 128 then + BlackWhite := clWhite + else + BlackWhite := clBlack; +end; + +procedure TMainForm.SaveCurrentTile1Click(Sender: TObject); + var + bmpTemp: TBitmap; + i, j, c: Integer; + { Mono: Boolean; } +begin + SavePictureDialog.DefaultExt := GraphicExtension(TBitmap); + if SavePictureDialog.Execute then + begin + bmpTemp := TBitmap.Create; + SetStretchBltMode(bmpTemp.Canvas.Handle, HALFTONE); +// bmpTemp.PixelFormat := pf16bit; +// bmpTemp.Canvas.CopyRect (Rect (0, 0, W, H), +// bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + { Mono := FALSE; } + case SavePictureDialog.FilterIndex of + 1: bmpTemp.PixelFormat := pf24bit; + 2: bmpTemp.PixelFormat := pf16bit; + 3: bmpTemp.PixelFormat := pf15bit; + 4: bmpTemp.PixelFormat := pf8bit; + 5: bmpTemp.PixelFormat := pf4bit; + 6: begin + bmpTemp.PixelFormat := pf1bit; + { Mono := TRUE; } + end; + 7: bmpTemp.PixelFormat := pf24bit; // PNG + end; + bmpTemp.Width := W; + bmpTemp.Height := H; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + begin + c := bmp.Canvas.Pixels[i + BORDER_W, j + BORDER_H]; + { + if Mono then + bmpTemp.Canvas.Pixels[i, j] := BlackWhite (c) + else + } + bmpTemp.Canvas.Pixels[i, j] := c; + end; + if UpperCase (ExtractFileExt (SavePictureDialog.Filename)) = '.PNG' then + begin + bmpTemp.TransparentColor := TRANS_COLOR; + WriteBitmapToPngFile (SavePictureDialog.Filename, bmpTemp, TRANS_COLOR); + end + else + bmpTemp.SaveToFile (SavePictureDialog.FileName); + bmpTemp.Free; + end; +end; + +{$IFNDEF IMPORTEDLEV} +procedure TMainForm.ImportEdlevClick(Sender: TObject); +begin + ShowMessage ('Not implemented in this version.'); +end; +{$ELSE} +procedure TMainForm.ImportEdlevClick(Sender: TObject); + var + i: Integer; + dir: string; +begin +{ + SetEditorMode (mTile); + ImportLevelTiles ('d:\dos\old\ch3\', 'MainChar', 40, 48, 'c'); + + SetEditorMode (mTile); + ImportLevelTiles ('d:\dos\old\ch3\', 'W1', 32, 24); + SetEditorMode (mMap); + ImportLevelMap ('d:\dos\old\ch3\', 'L1', 'L1'); +} + +{ + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W1', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'TITLE', 'Title'); + + ImportLevelMap ('c:\ch2\', 'P1', 'T1'); + ImportLevelMap ('c:\ch2\', 'P1B', 'T1B'); + + ImportLevelMap ('c:\ch2\', 'L1', 'L1'); + ImportLevelMap ('c:\ch2\', 'L1B', 'L1B'); + ImportLevelMap ('c:\ch2\', 'L2', 'L2'); + ImportLevelMap ('c:\ch2\', 'L3', 'L3'); + ImportLevelMap ('c:\ch2\', 'L3B', 'L3B'); + ImportLevelMap ('c:\ch2\', 'L4', 'L4'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W2', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'L5', 'L5'); + ImportLevelMap ('c:\ch2\', 'L5B', 'L5B'); + ImportLevelMap ('c:\ch2\', 'L6', 'L6'); + ImportLevelMap ('c:\ch2\', 'L7', 'L7'); + ImportLevelMap ('c:\ch2\', 'L7B', 'L7B'); + ImportLevelMap ('c:\ch2\', 'L8', 'L8'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W3', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'L9', 'L9'); + ImportLevelMap ('c:\ch2\', 'L9B', 'L9B'); + ImportLevelMap ('c:\ch2\', 'LA', 'LA'); + ImportLevelMap ('c:\ch2\', 'LB', 'LB'); + ImportLevelMap ('c:\ch2\', 'LBB', 'LBB'); + ImportLevelMap ('c:\ch2\', 'LC', 'LC'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W4', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'X1', 'X1'); + ImportLevelMap ('c:\ch2\', 'X1B', 'X1B'); + ImportLevelMap ('c:\ch2\', 'X2', 'X2'); + ImportLevelMap ('c:\ch2\', 'X3', 'X3'); + ImportLevelMap ('c:\ch2\', 'X3B', 'X3B'); + ImportLevelMap ('c:\ch2\', 'X4', 'X4'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W5', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'X5', 'X5'); + ImportLevelMap ('c:\ch2\', 'X5B', 'X5B'); + ImportLevelMap ('c:\ch2\', 'X6', 'X6'); + ImportLevelMap ('c:\ch2\', 'X7', 'X7'); + ImportLevelMap ('c:\ch2\', 'X7B', 'X7B'); + ImportLevelMap ('c:\ch2\', 'X8', 'X8'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W6', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'X9', 'X9'); + ImportLevelMap ('c:\ch2\', 'X9B', 'X9B'); + ImportLevelMap ('c:\ch2\', 'XA', 'XA'); + ImportLevelMap ('c:\ch2\', 'XB', 'XB'); + ImportLevelMap ('c:\ch2\', 'XBB', 'XBB'); + ImportLevelMap ('c:\ch2\', 'XC', 'XC'); + + ImportLevelTiles ('c:\ch2\', 'MainChar', 20, 28, 'c'); + + ImportLevelTiles ('c:\ch2\', 's20x28', 20, 28, 's'); + ImportLevelTiles ('c:\ch2\', 's20x16', 20, 16, 's'); + ImportLevelTiles ('c:\ch2\', 's24x14', 20, 14, 's'); + ImportLevelTiles ('c:\ch2\', 's24x14', 24, 14, 's'); + ImportLevelTiles ('c:\ch2\', 's8x7', 8, 7, 's'); + ImportLevelTiles ('c:\ch2\', 's8x8', 8, 8, 's'); + ImportLevelTiles ('c:\ch2\', 's40x28', 40, 28, 's'); + ImportLevelTiles ('c:\ch2\', 's40x6', 40, 6, 's'); + ImportLevelTiles ('c:\ch2\', 's20x6', 20, 6, 's'); + ImportLevelTiles ('c:\ch2\', 's32x28', 32, 28, 's'); + ImportLevelTiles ('c:\ch2\', 's10x14', 10, 14, 's'); + ImportLevelTiles ('c:\ch2\', 's20x18', 20, 18, 's'); + ImportLevelTiles ('c:\ch2\', 's40x24', 40, 24, 's'); + ImportLevelTiles ('c:\ch2\', 's32x24', 32, 24, 's'); + ImportLevelTiles ('c:\ch2\', 's20x24', 20, 24, 's'); + ImportLevelTiles ('c:\ch2\', 's12x8', 12, 8, 's'); + ImportLevelTiles ('c:\ch2\', 's12x7', 12, 7, 's'); + ImportLevelTiles ('c:\ch2\', 's26x16', 26, 16, 's'); + ImportLevelTiles ('c:\ch2\', 's32x18', 32, 18, 's'); +} + + for i := 0 to Tab.Tabs.Count - 1 do + begin + Tab.TabIndex := i; + TabChange (nil); + RemoveDuplicateTiles1Click(nil); + end; +end; + +procedure TMainForm.ImportAnySize (dir: string; extc: Char); + var + F: file of Byte; + SR: TSearchRec; + Wd, Ht: Byte; + ai: array of Integer; + i: Integer; + L: Integer; + Found: Boolean; +begin + SetLength (ai, 0); + if FindFirst (dir + '*.' + extc + '??', faAnyFile, SR) = 0 then + repeat + AssignFile (F, dir + SR.Name); + Reset (F); + if FileSize (F) <= 64 * 64 then + begin + BlockRead (F, Wd, SizeOf (Wd)); + BlockRead (F, Ht, SizeOf (Ht)); + if (Wd <= 64) and (Ht <= 64) and (FileSize (F) = Wd * Ht + 2 * SizeOf (Byte)) then + begin + L := Length (ai); + Found := FALSE; + for i := 0 to L - 1 do + if ai[i] = (Ht shl 8) + Wd then + Found := TRUE; + if not Found then + begin + SetLength (ai, L + 1); + ai[L] := (Ht shl 8) + Wd; + end; + end; + end; + CloseFile (F); + until FindNext (SR) <> 0; + FindClose (SR); + + for i := 0 to Length (ai) - 1 do + begin + Wd := ai[i] and $FF; + Ht := (ai[i] shr 8) and $FF; + ImportLevelTiles (dir, 's' + IntToStr (Wd) + 'x' + IntToStr (Ht), Wd, Ht, extc); + end; + + SetLength (ai, 0); +end; + +procedure TMainForm.ImportLevelTiles (dir, name: string; ww, hh: Integer; extc: Char); + var + TB: TBitmap; + FT: TextFile; + F: file; + s: string; + Pal: array[0..255, 0..2] of Byte; + ai: array of Integer; + TmpBmpName: string; + i, j: Integer; + SR: TSearchRec; + + procedure ReadTile (filename: string); + var + i, j, k: Integer; + Wd, Ht: Byte; + b: Byte; + begin + AssignFile (F, filename); + Reset (F, 1); + BlockRead (F, Wd, SizeOf (Wd)); + BlockRead (F, Ht, SizeOf (Ht)); + TB.Height := TB.Height + hh; + if (Wd = ww) and (Ht = hh) then + begin + for j := 0 to Ht - 1 do + for i := 0 to Wd - 1 do + begin + BlockRead (F, b, SizeOf (b)); + if b = 0 then + k := TRANS_COLOR + else + k := RGB (Pal[b, 0], Pal[b, 1], Pal[b, 2]); + TB.Canvas.Pixels[i, TB.Height - hh + j] := k; + end; + end; + CloseFile (F); + end; + +begin + TmpBmpName := '$tmp$bmp$.bmp'; + + TB := TBitmap.Create; + SetStretchBltMode(TB.Canvas.Handle, HALFTONE); + TB.PixelFormat := pf24bit; + TB.Width := ww; + + SetLength (ai, 2); + ai[0] := TRANS_COLOR; + ai[1] := TRANS_COLOR; + + AssignFile (F, dir + 'DEFAULT.PAL'); + Reset (F, 1); + BlockRead (F, Pal, SizeOf (Pal)); + CloseFile (F); + for i := 0 to 255 do + for j := 0 to 2 do + Pal[i, j] := Pal[i, j] shl 2; + + if (extc = #0) and FileExists (dir + 'NUMBERS.EDL') then + begin + AssignFile (FT, dir + 'NUMBERS.EDL'); + Reset (FT); + repeat + ReadLn (FT, s); + if FileExists (dir + s) then + ReadTile (dir + s); + until Eof (FT) or (s = ''); + CloseFile (FT); + end + else + begin + if FindFirst (dir + '*.' + extc + '??', faAnyFile, SR) = 0 then + repeat + ReadTile (dir + SR.Name); + + until FindNext (SR) <> 0; + FindClose (SR); + end; + + TB.SaveToFile (TmpBmpName); + TB.Free; + + CreateNewTileCollection (name, ww, hh, TRUE); + FreeTBR (TileTab[Tab.TabIndex].tbr); + MainForm.ProgressPanel.Visible := TRUE; + TileTab[Tab.TabIndex].tbr := + ReadTileBitmap (TmpBmpName, + ww, hh, 0, 0, + ai, 0, 0, 0, 0, + ProgressBar, + FALSE, + FALSE, + FALSE, + TileTab[Tab.TabIndex].tbr); + + SetLength (ai, 0); + MainForm.ProgressPanel.Visible := FALSE; + + TabChange (nil); + Modified := TRUE; +end; + +procedure TMainForm.ImportLevelMap (dir, filename, name: string); + type + MapDataRec = + record + BGNr, + FGNr: Word; + BGAdd, + FGAdd, + Bound, + Code: Byte; + end; + ReplaceRec = + record + OldNr: Word; + Add: Byte; + NewNr: Word; + end; + var + F: file; + sig: array[0..3] of Char; + HSize, VSize: SmallInt; + ww, hh: SmallInt; + mdr: MapDataRec; + i, j, k, x, y: Integer; + repl: array of ReplaceRec; + SeqNr: Integer; + + function GetAddTile (N: Word; Add: Byte): Word; + var + F: file; + FT: TextFile; + s: string; + Pal: array[0..255, 0..2] of Byte; + i, j, k: Integer; + Wd, Ht: Byte; + b: Byte; + begin + for i := 0 to Length (repl) - 1 do + if (repl[i].OldNr = N) and (repl[i].Add = Add) then + begin + GetAddTile := repl[i].NewNr; + Exit; + end; + + CreateNewTile (TileTab[Tab.TabIndex].tbr); + + AssignFile (F, dir + 'DEFAULT.PAL'); + Reset (F, 1); + BlockRead (F, Pal, SizeOf (Pal)); + CloseFile (F); + for i := 0 to 255 do + for j := 0 to 2 do + Pal[i, j] := Pal[i, j] shl 2; + + AssignFile (FT, dir + 'NUMBERS.EDL'); + Reset (FT); + for k := 1 to N - 1 do + ReadLn (FT); + ReadLn (FT, s); + if FileExists (dir + s) then + begin + AssignFile (F, dir + s); + Reset (F, 1); + BlockRead (F, Wd, SizeOf (Wd)); + BlockRead (F, Ht, SizeOf (Ht)); + if (Wd = W) and (Ht = H) then + begin + for j := 0 to Ht - 1 do + for i := 0 to Wd - 1 do + begin + BlockRead (F, b, SizeOf (b)); + if b = 0 then + k := TRANS_COLOR + else + begin + b := (b + Add) mod 256; + k := RGB (Pal[b, 0], Pal[b, 1], Pal[b, 2]); + end; + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := k; + end; + end; + CloseFile (F); + end; + CloseFile (FT); + + i := Length (repl); + SetLength (repl, i + 1); + repl[i].OldNr := N; + repl[i].Add := Add; + repl[i].NewNr := TileTab[Tab.TabIndex].tbr.TileCount - 1; + + //UpdateBmp (TRUE); + + with TileTab[Tab.TabIndex] do + tbr.TileBitmap.Canvas.CopyRect (MakeRect (tbr.Current * W, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + + + UpdateTileBitmap; + GetAddTile := TileTab[Tab.TabIndex].tbr.TileCount - 1; + end; + + function CmpMCR (mcr1, mcr2: MapCellRec): Boolean; + begin + CmpMCR := (mcr1.Back = mcr2.Back) and (mcr1.Mid = mcr2.Mid) and + (mcr1.Front = mcr2.Front) and (mcr1.Bounds = mcr2.Bounds); + end; + +begin { ImportLevelMap } + SetEditorMode (mMap); + + HSize := 0; + VSize := 0; + SetLength (repl, 0); + AssignFile (F, dir + filename); + Reset (F, 1); + + BlockRead (F, sig, SizeOf (sig)); + +// if (sig[0] = 'M') and (sig[1] = 'A') and (sig[2] = 'P') then + begin + if (sig[0] = 'M') and (sig[1] = 'A') and (sig[2] = 'P') then + begin + BlockRead (F, HSize, SizeOf (HSize)); + BlockRead (F, VSize, SizeOf (VSize)); + BlockRead (F, ww, SizeOf (ww)); + BlockRead (F, hh, SizeOf (hh)); + end + else + begin + CloseFile (F); + + AssignFile (F, dir + filename); + Reset (F, 1); + BlockRead (F, HSize, SizeOf (HSize)); + BlockRead (F, VSize, SizeOf (VSize)); + ww := W; + hh := H; + end; + + if (ww = W) and (hh = H) then + begin + NewMap (TileTab[Tab.TabIndex].tbr, name, HSize, VSize); + + MapTab.TabIndex := MapTab.Tabs.Add (name); + MapTabChange (nil); + + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + for j := 0 to VSize - 1 do + for i := 0 to HSize - 1 do + begin + BlockRead (F, mdr, SizeOf (mdr)); + + with Map[j, i], mdr do + begin + if FGNr and $FFF <> 0 then + begin + if FGAdd <> 0 then + FGNr := (FGNr and $F000) + (GetAddTile (FGNr and $FFF, FGAdd) + 1); + Mid := SmallInt ((FGNr and $CFFF) - 1); + end; + if BGNr and $FFF <> 0 then + begin + if BGAdd <> 0 then + BGNr := (BGNr and $F000) + (GetAddTile (BGNr and $FFF, BGAdd) + 1); + if BGNr and $2000 = $2000 then + Front := SmallInt ((BGNr and $CFFF) - 1) + else + Back := SmallInt ((BGNr and $CFFF) - 1); + end; + + Bounds := ShortInt (Bound); + MapCode := Code; + end; + + end; + end; + + end; + end; + CloseFile (F); + Modified := TRUE; + SetLength (repl, 0); + + SetEditorMode (mMap); + + // sequences: + i := 0; + SeqNr := SeqTab.Tabs.Count; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + while (i < HSize - 1) and (Map[0, i].MapCode = $FF) do + begin + j := 0; + while (j < VSize - 1) and (Map[j, i].MapCode = $FF) + and (not EmptyMCR (Map[j + 1, i])) do + begin + Area.Top := j + 1; + Area.Left := i; + Area.Bottom := j + 1; + Area.Right := i; + + k := j + 1; + while (k <= VSize - 1) and (Map[k, i].MapCode <> $FF) and + (not EmptyMCR (Map[k, i])) do + Inc (k); + if k <= VSize - 1 then + begin + for y := 0 to VSize - 1 do + for x := i + 1 to HSize - 1 do + if CmpMCR (Map[y, x], Map[Area.Top, Area.Left]) then + with Map[y, x] do + begin + // Bounds := $FF; + // Bounds := ShortInt ($80); + Bounds := $40; + Back := -1; + Mid := -1; + Front := -1; + MapCode := SeqNr; + end; + + Area.Bottom := k - 1; + Selection := TRUE; + ConverttoTileSequence1Click (nil); + Inc (SeqNr); + Selection := FALSE; + end; + j := k; + end; + Inc (i); + end; + + // remove first columns + if i > 0 then + for y := 0 to VSize - 1 do + begin + for x := i to HSize - 1 do + Map[y, x - i] := Map[y, x]; + SetLength (Map[y], Length (Map[y]) - i); + end; + end; + + SetEditorMode (mTile); +end; +{$ENDIF} + +procedure TMainForm.InsertHorizontal1Click(Sender: TObject); + var + InsPos, InsCount: Integer; + MapH, i, j: Integer; +begin + InsPos := 0; + InsCount := 1; + if Selection then + begin + InsPos := Area.Left; + InsCount := Area.Right - Area.Left + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapH := Length (Map); + for j := 0 to MapH - 1 do + begin + SetLength (Map[j], Length (Map[j]) + InsCount); + for i := Length (Map[j]) - 1 downto InsPos + InsCount do + Map[j, i] := Map[j, i - InsCount]; +// for i := 0 to InsCount - 1 do +// ClearMCR (Map[j, InsPos + i]); + end; + end; + Area := Rect (InsPos, 0, InsPos + InsCount - 1, MapH - 1); + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.DeleteHorizontal1Click(Sender: TObject); + var + DelPos, DelCount: Integer; + MapH, i, j: Integer; +begin + DelPos := 0; + DelCount := 1; + if Selection then + begin + DelPos := Area.Left; + DelCount := Area.Right - Area.Left + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapH := Length (Map); + for j := 0 to MapH - 1 do + begin + for i := DelPos + DelCount to Length (Map[j]) - 1 do + Map[j, i - DelCount] := Map[j, i]; + i := Length (Map[j]) - DelCount; + if i < 0 then i := 0; + SetLength (Map[j], i); + end; + end; + Selection := FALSE; + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.InsertVertical1Click(Sender: TObject); + var + InsPos, InsCount: Integer; + MapW, i, j: Integer; +begin + InsPos := 0; + InsCount := 1; + if Selection then + begin + InsPos := Area.Top; + InsCount := Area.Bottom - Area.Top + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapW := 0; + if Length (Map) > 0 then + MapW := Length (Map[0]); + SetLength (Map, Length (Map) + InsCount); + for j := 0 to InsCount - 1 do + SetLength (Map[Length (Map) - 1 - j], MapW); + for j := Length (Map) - 1 downto InsPos + InsCount do + for i := 0 to MapW - 1 do + Map[j, i] := Map[j - InsCount, i]; + end; + { RD: clear selection and redraw map with new dimensions } + Area := Rect (0, InsPos, MapW - 1, InsPos + InsCount - 1); + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.DeleteVertical1Click(Sender: TObject); + var + DelPos, DelCount: Integer; + MapW, i, j: Integer; +begin + DelPos := 0; + DelCount := 1; + if Selection then + begin + DelPos := Area.Top; + DelCount := Area.Bottom - Area.Top + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapW := 0; + if Length (Map) > 0 then + MapW := Length (Map[0]); + for j := DelPos + DelCount to Length (Map) - 1 do + for i := 0 to MapW - 1 do + Map[j - DelCount, i] := Map[j, i]; + for j := 0 to DelCount - 1 do + SetLength (Map[Length (Map) - 1 - j], MapW); + SetLength (Map, Length (Map) - DelCount); + end; + Selection := FALSE; + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.FormShow(Sender: TObject); +begin + if ReadParamFile then + begin + Modified := FALSE; + Open1Click (nil); + {CMDLINE-OPS} + ReadParamFile := ParamCount > 1; + if ReadParamFile then + begin + + + ReadParamCMD := ParamStr(2); + + if ReadParamCMD = 'F10' then + begin + Generate1Click(Self); + Modified := FALSE; + Exit1Click(Self); + end; + end; + {CMDLINE-OPS} + end; + ReadParamFile := FALSE; +end; + +procedure TMainForm.Tutorial1Click(Sender: TObject); + var + Param: string; +begin + Param := ApplPath + 'Tutorial\tutor.html'; + ShellExecute (0, 'open', PChar (Param), Nil, Nil, SW_SHOWNORMAL); +end; + +procedure TMainForm.OutputtoProjectDirectory1Click(Sender: TObject); +begin + SelectOutputDirectory1.Checked := FALSE; + OutputtoProjectDirectory1.Checked := TRUE; + OutputPath := FilePath (FileName); +end; + +procedure TMainForm.RecentFileClick (Sender: TObject); +begin + with Sender as TMenuItem do + begin + ReadParamFile := TRUE; + FileToOpen := RecentFiles.Strings[Tag]; + Open1Click (Nil); + ReadParamFile := FALSE; + end; +end; + +procedure TMainForm.AddFileToRecentProjects (FileName: string); + var + i: Integer; +begin + RecentFiles.Insert (0, FileName); + for i := 1 to RecentFiles.Count - 1 do + if i <= RecentFiles.Count - 1 then + if UpCaseStr (RecentFiles.Strings[i]) = UpCaseStr (FileName) then + RecentFiles.Delete (i); + UpdateRecentFilesMenu; +end; + +procedure TMainForm.ReadConfigFile; + var + F: TextFile; + s: string; + + procedure ReadRecentFiles; + var + s: string; + begin + ReadLn (F, s); + while (not Eof (F)) and (s <> '') do + begin + RecentFiles.Append (s); + ReadLn (F, s); + end; + end; + + procedure ReadWindowState; + var + s: string; + C: Char; + Error: Boolean; + V, Code: Integer; + begin + Error := FALSE; + ReadLn (F, s); + repeat + if (Length (s) > 2) and (s[2] = '=') then + begin + C := s[1]; + Delete (s, 1, 2); + Val (s, V, Code); + if Code <> 0 then + Error := TRUE + else + case C of + 'X': WinLeft := V; + 'Y': WinTop := V; + 'W': WinWidth := V; + 'H': WinHeight := V; + end; + end; + + if not Error then + ReadLn (F, s); + until Eof (F) or (s = '') or Error; + end; + + procedure ReadSettings; + var + s, Name: string; + Error: Boolean; + V, Code: Integer; + begin + Error := FALSE; + ReadLn (F, s); + repeat + if (Pos ('=', s) > 0) then + begin + Name := Copy (s, 1, Pos ('=', s) - 1); + Delete (s, 1, Pos ('=', s)); + Val (s, V, Code); + if Code <> 0 then + Error := TRUE + else + begin + if Name = 'Trans' then TRANS_COLOR := V; + if Name = 'Replace' then TRANS_COLOR_REPLACEMENT := V; + end; + end; + + if not Error then + ReadLn (F, s); + until Eof (F) or (s = '') or Error; + end; + +begin { ReadConfigFile } + WinWidth := 800; + WinHeight := 600; + + if FileExists (ApplPath + CONFIG_FILE) then // bugfix 2.55 + begin + AssignFile (F, ApplPath + CONFIG_FILE); + Reset (F); + ReadLn (F, s); + if s = UpCaseStr (APPL_NAME) then + begin + + repeat + ReadLn (F, s); + if s = '[Recent Projects]' then + ReadRecentFiles; + if s = '[Window]' then + ReadWindowState; + if s = '[Settings]' then + ReadSettings; + until Eof (F); + + end; + CloseFile (F); + end; +end; + +procedure TMainForm.WriteConfigFile; + var + F: TextFile; + i: Integer; + R, G, B: Integer; +begin + if CDROM then { bug fix 2.43 } + Exit; + + AssignFile (F, ApplPath + CONFIG_FILE); + ReWrite (F); + WriteLn (F, UpCaseStr (APPL_NAME)); + WriteLn (F); + + WriteLn (F, '[Recent Projects]'); + for i := 0 to RecentFiles.Count - 1 do + WriteLn (F, RecentFiles.Strings[i]); + WriteLn (F); + + WriteLn (F, '[Window]'); + WriteLn (F, 'X=', MainForm.Left); + WriteLn (F, 'Y=', MainForm.Top); + WriteLn (F, 'W=', MainForm.Width); + WriteLn (F, 'H=', MainForm.Height); + WriteLn (F); + + WriteLn (F, '[Settings]'); + GetRGB (TRANS_COLOR, R, G, B); + WriteLn (F, 'Trans=$', Hex2 (R and $FF), Hex2 (G and $FF), Hex2 (B and $FF)); + GetRGB (TRANS_COLOR_REPLACEMENT, R, G, B); + WriteLn (F, 'Replace=$', Hex2 (R and $FF), Hex2 (G and $FF), Hex2 (B and $FF)); + WriteLn (F); + + CloseFile (F); +end; + +procedure TMainForm.SmoothPalette1Click(Sender: TObject); +begin + with SmoothPalette1 do + begin + Checked := not Checked; + RearrangePalette1.Enabled := not Checked; + end; + Palette.Repaint; +end; + +procedure TMainForm.PaletteManager1Click(Sender: TObject); + var + i: Integer; + + function FindOrig (n: Integer): Integer; + var + j: Integer; + begin + FindOrig := -1; + for j := 0 to Length (aiOrig) - 1 do + if aiOrig[j] = n then + FindOrig := j; + end; + +begin + with TileTab[Tab.TabIndex].tbr do // bug fix 2.34 + SelectedPalette := PaletteNumber; + + DefaultPaletteChanged := FALSE; + SelectedPaletteChanged := FALSE; + + // store numbers in case some palettes are deleted + SetLength (aiOrig, Length (aaiPal)); + for i := 0 to Length (aaiPal) - 1 do + aiOrig[i] := i; + + SetLength (aiUsedColors, 0); + if ShowUsedColors1.Checked then + with UsedColorsImage.Picture.Bitmap do + if Height - 1 <= 256 then + begin + SetLength (aiUsedColors, Height - 1); + for i := 0 to (Height - 1) - 1 do + aiUsedColors[i] := Canvas.Pixels[0, i + 1]; + end; + + PaletteManager.ShowModal; + + for i := 0 to Tab.Tabs.Count - 1 do + with TileTab[i].tbr do + if PaletteNumber <> -1 then + PaletteNumber := FindOrig (PaletteNumber); + + if DefaultPaletteChanged then + if DefaultPalette <> -1 then + begin + for i := 0 to Tab.Tabs.Count - 1 do + with TileTab[i].tbr do + if PaletteNumber = -1 then + PaletteNumber := DefaultPalette; + end; + + if SelectedPaletteChanged then + with TileTab[Tab.TabIndex].tbr do + PaletteNumber := SelectedPalette; + + if ShowCurrentPalette1.Checked then + begin + ShowCurrentPalette1.Checked := FALSE; + ShowCurrentPalette1Click (Sender); + end; +end; + + +// new 2.0 - move entire animation +procedure TMainForm.ImportPovRayanimation1Click(Sender: TObject); +begin + if not HasNoTiles (TileTab[Tab.TabIndex].tbr) then + if MessageDlg ('Current Tile Set will be overwritten by imported tiles.', + mtWarning, [mbOk, mbCancel], 0) <> mrOk then + Exit; + ImpPovAni.CurTileW := W; + ImpPovAni.CurTileH := H; + PovAni.ShowModal; + if ImpPovAni.Done then + begin + TabChange (Sender); + Modified := TRUE; + UpdateTileBitmap; + end; +end; + +procedure TMainForm.Up2Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Up1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.Down2Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Down1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.Left3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Left1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.Right3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Right1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.NoDelay1Click(Sender: TObject); +begin + if AnimationTimer.Enabled then + AnimationTimer.Interval := 1; +end; + +procedure TMainForm.ShowCurrentPalette1Click(Sender: TObject); + var + bmp: TBitmap; + i, p: Integer; +begin + UsedColors.ShowHint := TRUE; + with TileTab[Tab.TabIndex] do + p := tbr.PaletteNumber; + if p = -1 then + p := DefaultPalette; + with ShowCurrentPalette1 do + begin + Checked := not Checked; + if Checked then + begin + if p = -1 then + Msg ('No palette selected for this tile set and no default palette available.') + else + if aiPreset[p] = 0 then + Msg ('The selected palette is empty.') + else + begin + bmp := TBitmap.Create; + SetStretchBltMode(bmp.Canvas.Handle, HALFTONE); + with bmp do + begin + PixelFormat := pf24bit; + Width := 1; + Height := aiPreset[p]; + for i := 0 to aiPreset[p] - 1 do + Canvas.Pixels[0, i] := aaiPal[p, i]; + end; + UsedColorsImage.Picture.Bitmap := bmp; + bmp.Free; + UsedColorsImage.Stretch := TRUE; + UsedColors.Visible := TRUE; + MainForm.Resize; + end; + end + else + HideUsedColors; + end; + UsedColorSelect := FALSE; +end; + +procedure TMainForm.ImportMap1Click(Sender: TObject); + var + F: file of Byte; + i1: Byte; + i2: SmallInt; + i4, L: LongInt; + b4: array [0..3] of Byte; + MapX, MapY, MapW, MapH, N: Integer; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + if ImportMapDialog.Execute then + begin + MapX := 0; + MapY := 0; + MapW := Length (Map[0]); + MapH := Length (Map); + if Selection then + begin + MapX := Area.Left; + MapY := Area.Top; + MapW := Area.Right - Area.Left + 1; + MapH := Area.Bottom - Area.Top + 1; + end; + if MapW = 0 then + Exit; + AssignFile (F, ImportMapDialog.Filename); + try + Reset (F); + N := 0; + L := 0; + repeat + case (ImportMapDialog.FilterIndex - 1) div 2 of + 0: begin + Read (F, i1); + L := i1; + end; + 1: begin + Read (F, b4[0]); + Read (F, b4[1]); + Move (b4, i2, SizeOf (i2)); + L := i2; + end; + 2: begin + Read (F, b4[0]); + Read (F, b4[1]); + Read (F, b4[2]); + Read (F, b4[3]); + Move (b4, i4, SizeOf (i4)); + L := i4; + end; + end; + if (ImportMapDialog.FilterIndex - 1) mod 2 = 1 then + Dec (L); + if (L < 0) or (L >= TileTab[Tab.TabIndex].tbr.TileCount) then + L := -1; + + with Map[MapY + N div MapW, // y + MapX + N mod MapW] do // x + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: back := L; + 0: mid := L; + 1: front := L; + end; + + Inc (N); + until (N >= MapW * MapH) or Eof (f); + + finally + CloseFile (F); + end; + + UpdateMap; + Modified := TRUE; + end; +end; + +procedure TMainForm.ExportMap1Click(Sender: TObject); + var + F: file of Byte; + i1: Byte; + i2: SmallInt; + i4, L: LongInt; + b4: array [0..3] of Byte; + MapX, MapY, MapW, MapH, N: Integer; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + if ExportMapDialog.Execute then + begin + MapX := 0; + MapY := 0; + MapW := Length (Map[0]); + MapH := Length (Map); + if Selection then + begin + MapX := Area.Left; + MapY := Area.Top; + MapW := Area.Right - Area.Left + 1; + MapH := Area.Bottom - Area.Top + 1; + end; + if MapW = 0 then + Exit; + AssignFile (F, ExportMapDialog.Filename); + try + ReWrite (F); + N := 0; + L := 0; + repeat + with Map[MapY + N div MapW, // y + MapX + N mod MapW] do // x + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: L := back; + 0: L := mid; + 1: L := front; + end; + if (ExportMapDialog.FilterIndex - 1) mod 2 = 1 then + Inc (L); + + case (ExportMapDialog.FilterIndex - 1) div 2 of + 0: begin + i1 := Byte (L and $FF); + Write (F, i1); + end; + 1: begin + i2 := SmallInt (L and $FFFF); + Move (i2, b4, SizeOf (i2)); + Write (F, b4[0]); + Write (F, b4[1]); + end; + 2: begin + i4 := L; + Move (i4, b4, SizeOf (b4)); + Write (F, b4[0]); + Write (F, b4[1]); + Write (F, b4[2]); + Write (F, b4[3]); + end; + end; + Inc (N); + until (N >= MapW * MapH); + + finally + CloseFile (F); + end; + + UpdateMap; + Modified := TRUE; + end; +end; + +procedure TMainForm.RefreshImportedTiles1Click(Sender: TObject); + var + ai: array of Integer; + s: string; +begin + SetLength (ai, 0); + + with TileTab[Tab.TabIndex].tbr do + if RefreshData.OrgFilename = '' then + ShowMessage ('This tile set was not imported.') + else + begin + if not FileExists (RefreshData.OrgFilename) then // 2.5 refresh file doesn't exist + begin + if OpenPictureDialog.Execute then + begin + s := OpenPictureDialog.FileName; + if FileExists (s) then + RefreshData.OrgFilename := s; + end; + end; + + if FileExists (RefreshData.OrgFilename) then + begin + MainForm.ProgressPanel.Visible := TRUE; + + TileTab[Tab.TabIndex].tbr := + ReadTileBitmap ('', + W, H, 0, 0, + ai, + 0, 0, + 0, 0, + ProgressBar, + FALSE, + FALSE, + TRUE, + TileTab[Tab.TabIndex].tbr); + + TabChange (Sender); + Modified := TRUE; + UpdateTileBitmap; + end; + end; + + + + SetLength (ai, 0); + + MainForm.ProgressPanel.Visible := FALSE; + +end; + +var + LastTSX, LastTSY: Integer; + +procedure TMainForm.TileSelectionMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + GetTileArea; + TileSelection.Brush.Style := bsClear; + TileSelOrgX := X + TileSelection.Left; + TileSelOrgY := Y + TileSelection.Top; + MovingTileSel := TRUE; + MovingTileSelPixels := Button = mbLeft; + LastTSX := 0; + LastTSY := 0; + SaveTempBmp; +end; + +procedure TMainForm.TileSelectionMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + var + i, j: Integer; +begin + if MovingTileSel then + begin + i := ((X + TileSelection.Left) - TileSelOrgX) div Scale; + j := ((Y + TileSelection.Top) - TileSelOrgY) div Scale; + TileSelX1 := TileAreaX + i; + TileSelY1 := TileAreaY + j; + TileSelX2 := TileSelX1 + TileAreaW; + TileSelY2 := TileSelY1 + TileAreaH; + if (i <> LastTSX) or (j <> LastTSY) then + ShowTileSelection (TRUE); + LastTSX := i; + LastTSY := j; + if MovingTileSelPixels then + begin + + Bmp.Canvas.CopyRect (Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H), + TempBmp.Canvas, Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H)); + Bmp.Canvas.CopyRect (Rect (TileSelX1, TileSelY1, TileSelX2, TileSelY2), + TempBmp.Canvas, MakeRect (TileAreaX, TileAreaY, TileAreaW, TileAreaH)); + UpdateBMP (FALSE); + + end; + end; +end; + +procedure TMainForm.TileSelectionMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + TileSelection.Brush.Style := bsBDiagonal; + TileSelection.Brush.Color := $0080FFFF; + + MovingTileSel := FALSE; + + // SaveUndo ('Drop Selection'); + UpdateBmp (TRUE); + Modified := TRUE; + +{ + SaveUndo ('Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + with ClipBmp do + Bmp.Canvas.CopyRect (Rect (X1, Y1, X2, Y2), + ClipBmp.Canvas, MakeRect (0, 0, ClipBmp.Width, ClipBmp.Height)); + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; +} + +end; + +procedure TMainForm.Horizontal3Click(Sender: TObject); +begin + Horizontal3.Checked := not Horizontal3.Checked; + Vertical3.Checked := FALSE; + Diagonal1.Checked := FALSE; + GradientH := Horizontal3.Checked; + GradientV := FALSE; + GradientD := FALSE; + TileMouseMove (Sender, [], LastX, LastY); +end; + +procedure TMainForm.Vertical3Click(Sender: TObject); +begin + Horizontal3.Checked := FALSE; + Vertical3.Checked := not Vertical3.Checked; + Diagonal1.Checked := FALSE; + GradientH := FALSE; + GradientV := Vertical3.Checked; + GradientD := FALSE; + TileMouseMove (Sender, [], LastX, LastY); +end; + +procedure TMainForm.Diagonal1Click(Sender: TObject); +begin + Horizontal3.Checked := FALSE; + Vertical3.Checked := FALSE; + Diagonal1.Checked := not Diagonal1.Checked; + GradientH := FALSE; + GradientV := FALSE; + GradientD := Diagonal1.Checked; + TileMouseMove (Sender, [], LastX, LastY); +end; + +procedure TMainForm.ProjectInformation1Click(Sender: TObject); +begin + Info.Caption := 'Project Information - ' + ProjectName; + Info.ShowModal; +end; + +procedure TMainForm.Fill1Click(Sender: TObject); + var + x, y, i, j, k: Integer; +begin + SaveUndo ('Fill'); + GetTileArea; + if Erasing then + k := TRANS_COLOR + else + k := Color.Brush.Color; + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + Pixels[x + i, y + j] := k; + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + + + +procedure TMainForm.Lighten1Click(Sender: TObject); + var + x, y, i, j, k: Integer; + R, G, B, l: Integer; +begin + if Sender = Lighten1 then + SaveUndo ('Lighten') + else + SaveUndo ('Darken'); + GetTileArea; + l := 256 div (MaxRGB - 1); + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + begin + k := Pixels[x + i, y + j]; + if k <> TRANS_COLOR then + begin + GetRGB (k, R, G, B); + if Sender = Lighten1 then + k := RGB (LimitRGB (R + l), LimitRGB (G + l), LimitRGB (B + l)) + else + k := RGB (LimitRGB (R - l), LimitRGB (G - l), LimitRGB (B - l)); + Pixels[x + i, y + j] := k; + end; + end; + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.FormClose(Sender: TObject; var Action: TCloseAction); +begin + RTTimer.Enabled := FALSE; // 2.31 bug fix + + if Modified then // 2.0 bug fix + if not SaveChanges then + Action := caNone; + + if Action <> caNone then + begin + WriteConfigFile; + Quitting := TRUE; + // SetEditorMode (mTile); + CloseAll; + end; +end; + +procedure TMainForm.RealTimeLightening1Click(Sender: TObject); +begin + with RealTimeLightening1 do // 2.0 + Checked := not Checked; + RTTimer.Enabled := RealTimeLightening1.Checked; +end; + +procedure TMainForm.RTTimerTimer(Sender: TObject); +begin + if RealTimeLightening1.Checked then + if Drawing then + if not Busy then + if DrawingTool in [dtPoint, dtBrush, dtLine] then + begin + TileMouseUp (nil, LastButton, LastShift, LastX, LastY); + TileMouseDown (nil, LastButton, LastShift, LastX, LastY); + end; +end; + +procedure TMainForm.Darker1Click(Sender: TObject); // 2.2 +begin + if FromToFirst > 0 then + begin + Dec (FromToFirst); + Dec (FromToLast); + FromToPaint (Sender); + end; +end; + +procedure TMainForm.Lighter1Click(Sender: TObject); +begin + if FromToLast < MAX_FROM_TO - 1 then + begin + Inc (FromToFirst); + Inc (FromToLast); + FromToPaint (Sender); + end; +end; + + +// 2.4: change tile offset + +procedure TMainForm.Up3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetY[Current] > - H then + begin + Dec (OffsetY[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.Down3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetY[Current] < + H then + begin + Inc (OffsetY[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.Left4Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetX[Current] > - W then + begin + Dec (OffsetX[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.Right4Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetX[Current] < + W then + begin + Inc (OffsetX[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.ResetOffset1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + begin + OffsetX[Current] := 0; + OffsetY[Current] := 0; + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +// 2.42 +procedure TMainForm.UpdateMap; +begin + lmp := nil; + if MapTab.TabIndex > -1 then + lmp := SelectMap (TileTab[Tab.TabIndex].tbr, MapTab.Tabs[MapTab.TabIndex]); + if lmp <> nil then + begin + DrawMap(Rect(0, 0, -1, -1), false, false, false); + MapDisplay.Invalidate; + end; +end; + +procedure TMainForm.UpdateMapRegion(Region: TRect); +begin + DrawMap(Region, false, false, false); + MapDisplay.Invalidate; +end; + +procedure TMainForm.MapDisplayPaint(Sender: TObject); +var + r: TRect; + tw, th: integer; +begin + // To do: + // - Change DrawMap interface to reflect new functionality + // - Clean up zoom code + + with TileTab[Tab.TabIndex].tbr do + begin + tw := W * ZOOM_FACTOR div Zoom; // Warning: may truncate + th := (H - Overlap) * ZOOM_FACTOR div Zoom; // Warning: may truncate + end; + + // 2.5 + with TileTab[Tab.TabIndex].tbr.Maps.aMaps[MapTab.TabIndex] do + begin + CurMapH := Length (Map); + CurMapW := Length (Map[0]); + end; + MapDisplay.Width := tw * CurMapW; + MapDisplay.Height := th * CurMapH; + + with MapDisplay.Canvas.ClipRect do + r := Rect(Left div tw, + Top div th, + min(CurMapW - 1, -(-Right div tw)), + min(CurMapH - 1, -(-Bottom div th))); + if (VisibleMapRegion.Left <> r.Left) or (VisibleMapRegion.Top <> r.Top) + or (VisibleMapRegion.Right <> r.Right) + or (VisibleMapRegion.Bottom <> r.Bottom) then + begin + VisibleMapRegion := r; + DrawMap(Rect(0, 0, -1, -1), false, false, false); + end; + MapDisplay.Canvas.StretchDraw(Rect(r.Left * tw, r.Top * th, + (r.Right + 1) * tw - 1, (r.Bottom + 1) * th - 1), bmpMap); +end; + +procedure TMainForm.HideTileSetPanel1Click(Sender: TObject); +begin + with HideTileSetPanel1 do + begin + Checked := not Checked; + TilePanel.Visible := not Checked; + if Checked then + StatusBar.Parent := MainForm + else + StatusBar.Parent := TilePanel; + end; +end; + +procedure TMainForm.UseOldNoiseFunctions1Click(Sender: TObject); +begin + with UseOldNoiseFunctions1 do + Checked := not Checked; +end; + +procedure TMainForm.FormKeyPress(Sender: TObject; var Key: Char); + var + sp: TSpeedButton; +begin + if Key = '+' then + ZoomIn1Click(Sender); + if Key = '-' then + ZoomOut1Click(Sender); + + sp := nil; + if Mode = mTile then + begin + case Key of + '1': sp := PencilButton; + '2': sp := BrushButton; + '3': sp := LineButton; + '4': sp := RectButton; + '5': sp := EllipseButton; + '7': sp := FillButton; + '8': sp := FilledRectButton; + '9': sp := FilledEllipseButton; + '0': sp := SelectionButton; + end; + end; + if Mode = mMap then + begin + case Key of + '1': sp := MapPointButton; + '2': sp := BlockButton; + '3': sp := ZOrderButton; + '4': sp := MapRectButton; + end; + end; + if sp <> nil then + begin + sp.Down := True; + SetDrawingTool (sp); + end; +end; + +procedure TMainForm.ExportMapasImage1Click(Sender: TObject); + var + Scale, WW, HH, x, y, i, j, rgba, RR, GG, BB, R, G, B, C, Total, BGC: Integer; +begin + lmp := nil; + if MapTab.TabIndex > -1 then + lmp := SelectMap (TileTab[Tab.TabIndex].tbr, MapTab.Tabs[MapTab.TabIndex]); + if lmp <> nil then + begin + if SavePictureDialog.Execute then + begin + SavePictureDialog.DefaultExt := GraphicExtension (TBitmap); + bmpMapImage := TBitmap.Create; + + case SavePictureDialog.FilterIndex of + 1: bmpMapImage.PixelFormat := pf24bit; + 2: bmpMapImage.PixelFormat := pf16bit; + 3: bmpMapImage.PixelFormat := pf15bit; + 4: bmpMapImage.PixelFormat := pf8bit; + 5: bmpMapImage.PixelFormat := pf4bit; + 6: bmpMapImage.PixelFormat := pf1bit; + 7: bmpMapImage.PixelFormat := pf24bit; // PNG + end; + if ExtractFileExt (SavePictureDialog.Filename) = '' then + if SavePictureDialog.FilterIndex = 7 then + SavePictureDialog.Filename := SavePictureDialog.Filename + '.png' + else + SavePictureDialog.Filename := SavePictureDialog.Filename + '.bmp'; + + DrawMap (Rect(0, 0, -1, -1), TRUE, FALSE, FALSE); + + Scale := MapExportScaleDownFactor1.Tag; + if Scale <> 1 then + begin + BGC := TileTab[Tab.TabIndex].tbr.BackGr; + WW := bmpMapImage.Width; + HH := bmpMapImage.Height; + with bmpMapImage.Canvas do + begin + for y := 0 to HH div Scale - 1 do + for x := 0 to WW div Scale - 1 do + begin + RR := 0; + GG := 0; + BB := 0; + C := 0; + Total := 0; + for j := 0 to Scale - 1 do + for i := 0 to Scale - 1 do + begin + if (x * Scale + i < WW) and (y * Scale + j < HH) then + begin + rgba := Pixels[x * Scale + i, y * Scale + j]; + if rgba <> BGC then + begin + GetRGB (rgba, R, G, B); + Inc (RR, R); + Inc (GG, G); + Inc (BB, B); + Inc (C); + end; + Inc (Total); + end; + end; + if C < Total div 2 then + Pixels[x, y] := BGC + else + Pixels[x, y] := RGB (RR div C, GG div C, BB div C); + end; + end; + bmpMapImage.Width := WW div Scale; + bmpMapImage.Height := HH div Scale; + end; + + if UpperCase (ExtractFileExt (SavePictureDialog.Filename)) = '.PNG' then + begin + bmpMapImage.TransparentColor := TRANS_COLOR; + WriteBitmapToPngFile (SavePictureDialog.Filename, bmpMapImage, TRANS_COLOR); + end + else + bmpMapImage.SaveToFile (SavePictureDialog.FileName); + bmpMapImage.Free; + end; + end; +end; + +procedure TMainForm.RotateRight1Click(Sender: TObject); + var + i, j: Integer; + ai: array of Integer; +begin + SaveUndo ('Rotate Right'); + GetTileArea; + with Bmp.Canvas do + if TileAreaW <> TileAreaH then + MessageDlg ('Not (yet) implemented for non-square tiles/areas.', mtError, [mbOk], 0) + else + begin + SetLength (ai, TileAreaW * TileAreaH); + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + ai[i + j * TileAreaW] := Pixels[TileAreaX + i, TileAreaY + j]; + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + Pixels[TileAreaX + i, TileAreaY + j] := ai[j + (TileAreaW - 1 - i) * TileAreaW]; + if not TileSelection.Visible then + RotateBounds (Bounds, -90); + end; + + UpdateBmp (TRUE); +end; + +procedure TMainForm.RotateLeft1Click(Sender: TObject); + var + i, j: Integer; + ai: array of Integer; +begin + SaveUndo ('Rotate Right'); + GetTileArea; + with Bmp.Canvas do + if TileAreaW <> TileAreaH then + MessageDlg ('Not (yet) implemented for non-square tiles/areas.', mtError, [mbOk], 0) + else + begin + SetLength (ai, TileAreaW * TileAreaH); + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + ai[i + j * TileAreaW] := Pixels[TileAreaX + i, TileAreaY + j]; + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + Pixels[TileAreaX + i, TileAreaY + j] := ai[TileAreaH - 1 - j + i * TileAreaW]; + if not TileSelection.Visible then + RotateBounds (Bounds, +90); + end; + + UpdateBmp (TRUE); +end; + +procedure TMainForm.aaClick(Sender: TObject); + var + s: string; +begin + with Sender as TMenuItem do + begin + s := Caption; + if s[1] = '&' then + system.Delete (s, 1, 1); + if Length (s) = 1 then + aaN := StrToInt (s) + else + aaN := 1; // Off + AntiAliasing1.Caption := '&Anti-Aliasing (' + s + ')'; + Checked := TRUE; + end; +end; + +procedure TMainForm.ReplaceColors2Click(Sender: TObject); + var + FirstTile, LastTile, CurTile, OldCurTile: Integer; + X, Y, RGB, R, G, B: Integer; + FR, RR: Boolean; + FR1, FG1, FB1: Integer; + FR2, FG2, FB2: Integer; + RR1, RG1, RB1: Integer; + RR2, RG2, RB2: Integer; + tr, tg, tb: Integer; + ar, ag, ab: Integer; + DF1R, DF1G, DF1B: Real; + DF2R, DF2G, DF2B: Real; + DF1, DF2, DF: Real; + Avg: Integer; + + function Check (x, P, L, Tol: Integer; var DF1: Real; var DF2: Real): Boolean; + begin + Result := FALSE; + + DF1 := -1000; + DF2 := +1000; + + x := x - P; + if L > 0 then + begin + DF1 := (x - Tol) / L; + DF2 := (x + Tol) / L; + end + else + if L < 0 then + begin + DF1 := (x + Tol) / L; + DF2 := (x - Tol) / L; + end + else { L = 0 } + begin + if Abs (x) <= Abs (Tol) then + begin + DF1 := 0; + DF2 := 1; + end; + end; + if not ( ((DF1 < 0) and (DF2 < 0)) or + ((DF1 > 1) and (DF2 > 1)) ) then + Result := TRUE; + end; + +begin + Replace.CurColor := Color.Brush.Color; + Replace.ShowModal; + + with Replace, TileTab[Tab.TabIndex].tbr do + if Result then + begin + FR := FindRange.Checked; + RR := ReplaceRange.Checked; + GetRGB (FindColor1.Brush.Color, FR1, FG1, FB1); + if FR then + begin + GetRGB (FindColor2.Brush.Color, FR2, FG2, FB2); + Dec (FR2, FR1); + Dec (FG2, FG1); + Dec (FB2, FB1); + end + else + begin + FR2 := 0; + FG2 := 0; + FB2 := 0; + end; + + GetRGB (ReplaceColor1.Brush.Color, RR1, RG1, RB1); + if RR then + begin + GetRGB (ReplaceColor2.Brush.Color, RR2, RG2, RB2); + Dec (RR2, RR1); + Dec (RG2, RG1); + Dec (RB2, RB1); + end + else + begin + RR2 := 0; + RG2 := 0; + RB2 := 0; + end; + + tr := TolRed.Value; + tg := TolGreen.Value; + tb := TolBlue.Value; + ar := AddRed.Value; + ag := AddGreen.Value; + ab := AddBlue.Value; + + OldCurTile := Current; + FirstTile := Current; + LastTile := Current; + if All then + begin + FirstTile := 0; + LastTile := TileCount - 1; + end + else + SaveUndo ('Replace Colors'); + + for CurTile := FirstTile to LastTile do + begin + if All then + begin + Current := CurTile; + // StartEdit (FALSE); + + with TileTab[Tab.TabIndex] do // bug fix 2.55 - replace colors replaced tiles + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + tbr.TileBitmap.Canvas, MakeRect (tbr.Current * W, 0, W, H)); + + end; + GetTileArea; + + for Y := TileAreaY to TileAreaY + TileAreaH - 1 do + for X := TileAreaX to TileAreaX + TileAreaW - 1 do + begin + RGB := BMP.Canvas.Pixels[X, Y]; + if RGB <> TRANS_COLOR then + begin + GetRGB (RGB, R, G, B); + + if Check (R, FR1, FR2, tr, DF1R, DF2R) and + Check (G, FG1, FG2, tg, DF1G, DF2G) and + Check (B, FB1, FB2, tb, DF1B, DF2B) then + begin + DF1 := Max (Max (DF1R, DF1G), DF1B); + DF2 := Min (Min (DF2R, DF2G), DF2B); + if DF2 >= DF1 then + begin + DF := (DF2 + DF1) / 2; + + R := RR1 + Round (DF * RR2) + ar; + G := RG1 + Round (DF * RG2) + ag; + B := RB1 + Round (DF * RB2) + ab; + + BMP.Canvas.Pixels[X, Y] := MakePalRGB (R, G, B, 0); + end; + end; + + end; + end; + + + UpdateBMP (TRUE); + UpdateTileBitmap; + end; + + Current := OldCurTile; + DrawCursor; + Modified := TRUE; + end; +end; + +procedure TMainForm.UpdateTileGrid; // 2.51 + var + i, j, w, h: Integer; + LW, LH: Integer; + CD, CL: Integer; +begin + with TileTab[Tab.TabIndex] do + begin + Grid.Picture.Bitmap.Transparent := TRUE; + Grid.Picture.Bitmap.TransparentMode := tmFixed; + Grid.Picture.Bitmap.TransparentColor := TRANS_COLOR; + + w := tbr.W + 2 * BORDER_W; + h := tbr.H + 2 * BORDER_H; + + LW := tbr.W div 4; + if tbr.W mod 4 <> 0 then LW := 2 * tbr.W; + LH := tbr.H div 4; + if tbr.H mod 4 <> 0 then LH := 2 * tbr.H; + + Grid.Left := Tile.Left {+ BORDER_W * Scale}; + Grid.Top := Tile.Top {+ BORDER_H * Scale}; + if (w * Scale <> Grid.Width) or + (h * Scale <> Grid.Height) then + begin + Grid.Width := w * Scale; + Grid.Height := h * Scale; + with Grid.Picture.Bitmap do + begin + Width := w * Scale; + Height := h * Scale; + with Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := TRANS_COLOR; + Pen.Style := psSolid; + Pen.Color := TRANS_COLOR; + Rectangle (0, 0, Width, Height); + end; + for j := 0 to h - 1 do + for i := 0 to w - 1 do + begin + CD := clBlack; + CL := clWhite; + if LW * LH <> 0 then + if ((i - BORDER_W + LW) mod LW = LW - 1) or + ((j - BORDER_H + LH) mod LH = LH - 1) then + CL := clRed; + Canvas.Pixels[i * Scale, j * Scale] := CD; + Canvas.Pixels[i * Scale + Scale - 1, j * Scale + Scale - 1] := CL; + end; + end; + end; + + end; +end; + +procedure TMainForm.ShowTileGrid1Click(Sender: TObject); +begin + with ShowTileGrid1 do + begin + Checked := not Checked; + Grid.Visible := Checked; + end; +end; + +procedure TMainForm.ReplaceSelectedTile1Click(Sender: TObject); + var + i, j, x, y, w, h: Integer; + + function CompareMCR (mcr1, mcr2: MapCellRec): Boolean; + begin + CompareMCR := (mcr1.Back = mcr2.Back) and (mcr1.Mid = mcr2.Mid) and + (mcr1.Front = mcr2.Front); + end; + +begin + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + w := Min (Area.Right - Area.Left + 1, Length (clip^.Map[0])); + h := Min (Area.Bottom - Area.Top + 1, Length (clip^.Map)); + + with Area do + begin + for y := 0 to Length (lmp^.Map) - 1 do + for x := 0 to Length (lmp^.Map[y]) - 1 do + if ((x < Left) or (x > Left + W - 1)) or + ((y < Top) or (y > Top + H - 1)) then + begin + for j := 0 to H - 1 do + for i := 0 to W - 1 do + if CompareMCR (lmp^.Map[y, x], clip^.Map[j, i]) then + lmp^.Map[y, x] := lmp^.Map[Top + j, Left + i]; + end; + + // for j := 0 to H - 1 do + // for i := 0 to W - 1 do + // lmp^.Map[Top + j, Left + i] := clip^.Map[j, i]; + end; + + Selection := FALSE; + UpdateMap; + end; + Modified := TRUE; +end; + +procedure TMainForm.MoveMapLeft1Click(Sender: TObject); + var + lm: LayerMap; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if CurMap > 0 then + begin + lm := aMaps[CurMap]; + aMaps[CurMap] := aMaps[CurMap - 1]; + aMaps[CurMap - 1] := lm; + MapTab.Tabs.Move(CurMap, CurMap - 1); + Dec (CurMap); + MapTab.TabIndex := CurMap; + Modified := TRUE; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.MoveMapRight1Click(Sender: TObject); + var + lm: LayerMap; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if CurMap < Length (aMaps) - 1 then + begin + lm := aMaps[CurMap]; + aMaps[CurMap] := aMaps[CurMap + 1]; + aMaps[CurMap + 1] := lm; + MapTab.Tabs.Move(CurMap, CurMap + 1); + Inc (CurMap); + MapTab.TabIndex := CurMap; + Modified := TRUE; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.NextMap1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if Length (aMaps) > 0 then + begin + if CurMap < Length (aMaps) - 1 then + Inc (CurMap) + else + CurMap := 0; + MapTab.TabIndex := CurMap; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.PreviousMap1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if Length (aMaps) > 0 then + begin + if CurMap > 0 then + Dec (CurMap) + else + CurMap := Length (aMaps) - 1; + MapTab.TabIndex := CurMap; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.N110Click(Sender: TObject); +begin + with Sender as TMenuItem do + begin + MapExportScaleDownFactor1.Tag := Tag; + Checked := TRUE; + end; +end; + +procedure TMainForm.SplitColorPattern1Click(Sender: TObject); +begin + with SplitColorPattern1 do + begin + Checked := not Checked; + if Checked then + with OtherFromTo do + begin + FT := FromToList; + ExFT := ExFromToList; + F := FromToFirst; + L := FromToLast; + end; + FromTo.Repaint; + end; +end; + +procedure TMainForm.ShowBackLayerClick(Sender: TObject); +begin + ShowBackLayer.Checked := not ShowBackLayer.Checked; + UpdateMap; +end; + +procedure TMainForm.ShowMidLayerClick(Sender: TObject); +begin + ShowMidLayer.Checked := not ShowMidLayer.Checked; + UpdateMap; +end; + +procedure TMainForm.ShowFrontLayerClick(Sender: TObject); +begin + ShowFrontLayer.Checked := not ShowFrontLayer.Checked; + UpdateMap; +end; + +procedure TMainForm.SetGridGuidelines1Click(Sender: TObject); +begin + with SettingsForm do + begin + X.Value := MapGridX; + Y.Value := MapGridY; + Caption := 'Map Guidelines'; + ShowModal; + if Result then + begin + MapGridX := X.Value; + MapGridY := Y.Value; + UpdateMap; + end; + end; +end; + +procedure TMainForm.HalfSize1Click(Sender: TObject); + var + i, j, ShiftX, ShiftY: Integer; + XM, YM: array[0..1] of Integer; + WW, HH: Integer; + X1, Y1, X2, Y2: Integer; +begin + if Mode = mTile then + begin + if Clipboard.HasFormat(CF_BITMAP) then + begin + X1 := BORDER_W; + Y1 := BORDER_H; + X2 := X1 + W - 1; + Y2 := Y1 + H - 1; + + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + X1 := TileSelX1; + Y1 := TileSelY1; + X2 := TileSelX2; + Y2 := TileSelY2; + end; + + SaveUndo ('Scaled Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + + ShiftX := 0; + ShiftY := 0; + XM[0] := 0; + XM[1] := 0; + YM[0] := 0; + YM[1] := 0; + for j := 1 to ClipBmp.Height - 1 - 1 do + for i := 1 to ClipBmp.Width - 1 - 1 do + with ClipBmp.Canvas do + begin + if Pixels[i, j] = Pixels[i + 1, j] then + Inc (XM[i mod 2]); + if Pixels[i, j] = Pixels[i, j + 1] then + Inc (YM[j mod 2]); + end; + if XM[1] > XM[0] then ShiftX := 1; + if YM[1] > YM[0] then ShiftY := 1; + + WW := X2 - X1 + 1; + HH := Y2 - Y1 + 1; + WW := Min (WW, (ClipBmp.Width - ShiftX) div 2); + HH := Min (HH, (ClipBmp.Height - ShiftY) div 2); + + with ClipBmp do + Bmp.Canvas.CopyRect (MakeRect (X1, Y1, WW, HH), + ClipBmp.Canvas, MakeRect (ShiftX, ShiftY, 2 * WW, 2 * HH)); + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; + end; + end; + +end; + +procedure TMainForm.N256ColorPalette1Click(Sender: TObject); + var + PalFile: string; + i: Integer; +begin + Pal256 := not Pal256; + N256ColorPalette1.Checked := Pal256; + + if Pal256 then + with TileTab[Tab.TabIndex].tbr do + if PaletteNumber = -1 then + begin + PalFile := '.\' + DEFAULT_PAL; + if not FileExists (PalFile) then + PalFile := ApplPath + DEFAULT_PAL; + if FileExists (PalFile) then + begin + PaletteManager.NewButton.Click (); + PaletteManager.ImportPalette (PalFile, PaletteManager.PaletteTab.TabIndex, 2); + PalMan.DefaultPalette := PaletteManager.PaletteTab.TabIndex; + + if PalMan.DefaultPalette <> -1 then + begin + for i := 0 to Tab.Tabs.Count - 1 do + with TileTab[i].tbr do + if PaletteNumber = -1 then + PaletteNumber := PalMan.DefaultPalette; + end; + + end; + for i := 0 to 255 do + begin + Enable256[i] := True; //(Random (256) < 128); // True; + LastEnable256[i] := True; + end; + end; + + Palette.Repaint; +end; + +function TMainForm.CountEnabledColors: Integer; + var + i, j: Integer; +begin + j := 0; + for i := 0 to 255 do + if Enable256[i] then Inc (j); + Result := j; +end; + +procedure TMainForm.ReplaceCurrentTileSequence1Click(Sender: TObject); + var + i, j, m, n: Integer; + mcr: MapCellRec; +begin + if SeqTab.TabIndex > -1 then + begin + if not Selection then + Exit; + + // check if not empty + n := 0; + m := 0; // frame lengths provided as map codes? + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if mcr.MapCode > m then + m := mcr.MapCode; + if not EmptyMCR (mcr) then + Inc (n); + end; + + if n < 1 then + Exit; + + SeqW := n; + SeqH := 1; + + + with TileTab[Tab.TabIndex].tbr do + with Seq do + with aMaps[CurMap] do + SetMapSize (Map, SeqW, SeqH); + + n := 0; + with Area do + begin + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if not EmptyMCR (mcr) then + begin +// if m = 0 then +// mcr.MapCode := 25; + seq^.Map[0, n] := mcr; + Inc (n); + end; + end; + end; + + SeqTabChange (Sender); + + { RD: clear selection } + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end +end; + +// 3.00 +procedure TMainForm.SaveHistoryCoords (x1, y1, x2, y2: Integer); +begin + if bHistoryRec.Down then + begin + HistoryListBox.Items.Add(Format (' %d,%d, %d,%d', [x1, y1, x2, y2])); + end; +end; + +procedure TMainForm.bHistoryClearClick(Sender: TObject); + var + i: Integer; +begin + HistoryListBox.Items.Clear; + bHistoryClear.Down := False; + bHistoryRec.Down := True; + UpdateBMP (False); + for i := 0 to UndoCount - 1 do + Undo[i].HistoryCoords := ''; +end; + +procedure TMainForm.bHistoryShowClick(Sender: TObject); +begin + UpdateBMP (False); +end; + +procedure TMainForm.HistoryListBoxClick(Sender: TObject); +begin + UpdateBMP (False); +end; + +procedure TMainForm.ProjectLists1Click(Sender: TObject); +begin + Lists.ShowModal; +end; + +procedure TMainForm.bRGBEditClick(Sender: TObject); + var + filename: string; +begin + filename := ApplPath + RGBCONV_FILE; + RGBConv.lblFilename.Caption := filename; + if FileExists (filename) then + RGBConv.Script.Lines.LoadFromFile (filename); + RGBConv.ShowModal; + if RGBConv.Result then + begin + RGBConv.Script.Lines.SaveToFile (filename); + LoadRGBConvNames; + end; +end; + +procedure TMainForm.LoadRGBConvNames; + var + filename: string; + lines: TStringList; + LastSelected: string; + i, j: Integer; + s: string; +begin + filename := ApplPath + RGBCONV_FILE; + lines := TStringList.Create (); + lines.Clear; + if not FileExists (filename) then + begin + lines.Add ('[Black & White]'); + lines.Add ('R=(R+G+B)/3'); + lines.Add ('G=(R+G+B)/3'); + lines.Add ('B=(R+G+B)/3'); + lines.Add (''); + lines.Add ('[Invert]'); + lines.Add ('R=255-R'); + lines.Add ('G=255-G'); + lines.Add ('B=255-B'); + lines.Add (''); + lines.SaveToFile (filename); + end; + + for i := 0 to Length (RGBConvScripts) - 1 do + RGBConvScripts[i].Clear; + SetLength (RGBConvScripts, 0); + + lines.LoadFromFile (filename); + LastSelected := ''; + for i := 0 to RGBConvListBox.Items.Count - 1 do + if RGBConvListBox.Selected[i] then + LastSelected := RGBConvListBox.Items[i]; + RGBConvListBox.Items.Clear; + j := -1; + for i := 0 to lines.Count - 1 do + begin + s := lines.strings[i]; + s := trim (s); + if (s <> '') and (s[1] = '[') and (s[Length (s)] = ']') then + begin + Delete (s, 1, 1); + Delete (s, Length (s), 1); + RGBConvListBox.Items.Add (s); + + Inc (j); + SetLength (RGBConvScripts, j + 1); + + if (s = LastSelected) then + RGBConvListBox.ItemIndex := j; + + RGBConvScripts[j] := TStringList.Create; + end + else + if (j >= 0) and (s <> '') then + RGBConvScripts[j].Add (s) + end; +end; + +function TMainForm.ConvertPixel (color: Integer): Integer; + const + IdChars: set of Char = ['0'..'9', 'A'..'Z']; + var + i, j, k, r, g, b, resultR, resultG, resultB: Integer; + c: Char; + s: string; + N: LongInt; + p, ErrorPos: Integer; + F: ShortString; +begin + GetRGB (color, resultR, resultG, resultB); + for i := 0 to RGBConvListBox.Items.Count - 1 do + if RGBConvListBox.Selected[i] then + if (i < Length (RGBConvScripts)) then + begin + for j := 0 to RGBConvScripts[i].Count - 1 do + begin + s := trim (RGBConvScripts[i].Strings[j]); + if (s <> '') then + begin + c := UpCase (s[1]); + if (c = 'R') or (c = 'G') or (c = 'B') then + begin + Delete (s, 1, 1); + s := trim (s); + if (s <> '') and (s[1] = '=') then + begin + Delete (s, 1, 1); + if (s <> '') then + begin + s := '(' + UpCaseStr (s) + ')'; + GetRGB (color, r, g, b); + for k := Length (s) - 1 downto 1 + 1 do + if (not (s[k - 1] in IdChars)) and + (not (s[k + 1] in IdChars)) then + case s[k] of + 'R': begin + Delete (s, k, 1); + Insert (Format ('%d', [R]), s, k); + end; + 'G': begin + Delete (s, k, 1); + Insert (Format ('%d', [G]), s, k); + end; + 'B': begin + Delete (s, k, 1); + Insert (Format ('%d', [B]), s, k); + end; + end; + ErrorPos := 0; + p := 1; + F := s; + if Evaluate (N, F, p) then + begin + case c of + 'R': resultR := N; + 'G': resultG := N; + 'B': resultB := N; + end; + end; + + end; + end; + end; + end; + + end; + end; + ConvertPixel := RGB (LimitRGB (resultR), limitRGB (resultG), limitRGB (resultB)); +end; + +procedure TMainForm.bRGBRunClick(Sender: TObject); + var + x, y, i, j, k: Integer; +begin + SaveUndo ('RGB Script'); + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + if Pixels[x + i, y + j] <> TRANS_COLOR then + Pixels[x + i, y + j] := ConvertPixel (Pixels[x + i, y + j]); + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.SelectNextClip1Click(Sender: TObject); +begin + if ClipTab.Tabs.Count > 0 then + ClipTab.TabIndex := (ClipTab.TabIndex + 1) mod ClipTab.Tabs.Count; + ClipTabChange (Sender); +end; + +procedure TMainForm.SelectPreviousClip1Click(Sender: TObject); +begin + if ClipTab.Tabs.Count > 0 then + ClipTab.TabIndex := (ClipTab.TabIndex - 1 + ClipTab.Tabs.Count) mod ClipTab.Tabs.Count; + ClipTabChange (Sender); +end; + +procedure TMainForm.ReplaceColorUnderCursor1Click(Sender: TObject); + var + x, y, i, j: Integer; +begin + SaveUndo ('Replace Color'); + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + if Pixels[x + i, y + j] = ColorUnderMousePointer then + Pixels[x + i, y + j] := Color.Brush.Color; + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.Edit1Click(Sender: TObject); + var + map: Boolean; +begin + map := ((Mode = mMap) and (Selection and (ClipTab.TabIndex > -1) and (clip <> nil))); + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP) or map; + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP) or map; + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP) or map; +end; + +procedure TMainForm.UseAsAlphaChannel1Click(Sender: TObject); +begin + if Mode = mTile then + begin + if UseAsAlphaChannel1.Checked then + UseAsAlphaChannel1.Checked := FALSE + else + begin + UseAsAlphaChannel1.Checked := TRUE; + + AlphaBmp.Width := W; + AlphaBmp.Height := H; + AlphaBmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + LastTileEdited := -1; + end; + + AlphaPanel.Height := 12 + H; + AlphaPanel.Visible := UseAsAlphaChannel1.Checked; + AlphaPaintBox.Width := W; + AlphaPaintBox.Height := H; + + end; +end; + +procedure TMainForm.AlphaPaintBoxPaint(Sender: TObject); + var + i, j, k: Integer; + x: Integer; + rgba: Integer; + r, g, b: Integer; +begin + x := (AlphaPaintBox.Width - W) div 2; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + begin + rgba := AlphaBmp.Canvas.Pixels[i, j]; + if (rgba <> TRANS_COLOR) then + begin + GetRGB (rgba, r, g, b); + k := 255 - (r + g + b) div 3; + AlphaPaintBox.Canvas.Pixels[x + i, j] := rgb (k, k, k); + end + else + AlphaPaintBox.Canvas.Pixels[x + i, j] := AlphaPanel.Color; + end; + +end; + +procedure TMainForm.ShowUsedColorPatterns1Click(Sender: TObject); +begin + with ShowUsedColorPatterns1 do + if not Checked then + begin + Checked := TRUE; + + ColorPatternsPanel.Visible := TRUE; + MainForm.Resize; + end + else + begin + Checked := FALSE; + + ColorPatternsPanel.Visible := FALSE; + MainForm.Resize; + end; + UsedPatternSelect := FALSE; +end; + +procedure TMainForm.ColorPatternsImageMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + var + j: Integer; +begin + if UsedPatternSelect then + if Length (FromToSave) > 0 then + begin + j := Y * Length (FromToSave) div ColorPatternsImage.Height; + FromToSavePos := j; + SelectSavedFromToList; + if (FromToSave[j].F = FromToSave[j].L) then + SetColor (FromToSave[j].FT[FromToSave[j].F], False, False); + end; +end; + +procedure TMainForm.ColorPatternsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if (Button = mbLeft) then + begin + UsedPatternSelect := TRUE; + ColorPatternsImageMouseMove (Sender, Shift, X, Y); + end; +end; + +procedure TMainForm.ColorPatternsImageMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + var + i, j: Integer; +begin + if (not UsedPatternSelect) then + if (Button = mbRight) then + if Length (FromToSave) > 0 then + begin + j := Y * Length (FromToSave) div ColorPatternsImage.Height; + + for i := j + 1 to Length (FromToSave) - 1 do + FromToSave[i - 1] := FromToSave[i]; + SetLength (FromToSave, Length (FromToSave) - 1); + if (j >= Length (FromToSave)) then + j := 0; + + FromToSavePos := j; + if Length (FromToSave) > 0 then + SelectSavedFromToList + else + begin + ColorPatternsImage.Picture.Bitmap := TBitmap.Create; + with ColorPatternsImage.Picture.Bitmap do + begin + Width := 1; + Height := 1; + Canvas.Pixels[0, 0] := ColorPatternsPanel.Color; + end; + ColorPatternsImage.Repaint; + ColorPatternsImage.Refresh; + end; + DrawUsedFromToList; + end; + + UsedPatternSelect := FALSE; +end; + +procedure TMainForm.DoubleSize1Click(Sender: TObject); + var + i, j, k: Integer; + px, py: Integer; +begin + if Mode = mTile then + begin + if Clipboard.HasFormat(CF_BITMAP) then + begin + + SaveUndo ('Scaled Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + + GetTileArea (); + + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + begin + px := i div 2; + py := j div 2; + if (px < ClipBmp.Width) and (py < ClipBmp.Height) then + begin + k := ClipBmp.Canvas.Pixels[px, py]; + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := k; + end; + end; + + + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; + end; + end; + +end; + +procedure TMainForm.Edit1DrawItem(Sender: TObject; ACanvas: TCanvas; + ARect: TRect; Selected: Boolean); +begin + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); +end; + +procedure TMainForm.HideOnionSkin1Click(Sender: TObject); +begin + HideOnionSkin1.Checked := not HideOnionSkin1.Checked; + UpdateBMP (FALSE); +end; + +end. + diff --git a/ts.exe b/ts.exe new file mode 100644 index 0000000000000000000000000000000000000000..bdaf7f86376ecc4e667c51b2a51eef7f8f183a5c GIT binary patch literal 1067008 zcmd4433yaR)<1lENz#Od4iIDu617nxi-h1v2xyayur~<_VK_ff!TYJ)5P9E##i&dL%VbJhWzGJML_ z@etx2w=zFZ%~SL`qwa#3PMa1?B}Mu7YZZG6p_Ib4pQOi3o?JP--0TGgz`7 z$}28jxmq<)+Gz~4svMJ$+i->QQ9)hMKi2t8cMAUx~gQnlbAMH!E9TjUI?SV>{t{RImCiJFkZ zOFxQ|E@PWeWySdXpEk{vw*NSe}O1O6JTn2&<;P2=7>m~#uUZMnAo8WKJ-3t1k z6OS7He&`>CTM<}?cA`3Oe88bp;xAO^r{NCOx!;2BYUJy+XWrn*nB8*}!od=wB}PfK zO0-BcOH?Fw?b6eCN<1sEL*hw^<7IpB<_{iDsiX8?GhU$dL_Oi zu}f@9b&`d%DD4KstrAoDf^fF|#D(n`JR&S(6%E z(agu+q=Khdv~ZSUHKdyZ15N4Xq!f#*55j&g!pNH)P71huY#)1{=fJbv>oO;JweZEu zR-hb|pQo{twXsWV0%#?5l&obRnP!?9H$7-g`f&YyNgb|XEZJ;GvEVl@#p-#)s<<+c zLn4R;?qMIXUzklF%jmAKxJRsk+gT(iXjVIW#A15HI{JdP(QY2yp_N+MULQb@={CE*Xz?+lPSfTgpl<~NvhpaYS!=@^0clq zBav0sHHUxGCAcuMIjj*>NTQbwGJA)pg5_};_FwxEeCRsYPr)FU9j|NOL%R)@*E<}vI)Wl-!N#B$j*>@;H zOp)S{1^D}=o-Jsk77P`@t8*#lq0rbl%{u?piB>IZ4&H-ee5rWR(#w=ULeeAFEn_f1 z_G4i2ZQw|V9o5Ow#b8SB9!z(mcTOV1z?~QgpSoHwRGayEGyz4wiR~0a_ZT90rq~tN z3-Ev}2UXGLH8_&(ADv}I zS;1<&o$|-9Rn!CoS*yVg5FpE_6vQ&FSIL)HhWdz)B<3>PsjvJs-PBkUf2y0z#2#dB z2$8W>6oUP)B6SccB&k3Kd(e{ft!pwhCiHD z)Wdukh_a=2b49y4qPx^S!LMist46~JgA{1d8!ws~PEY%5DiDd@2$Y6|P&PZ6usgfx z_F)bsKR6*@ySZpP<&k(H7<5ma;hdu=YNYNp4qm!kdz@UND36lMo`VD%;413G2!Jd+ z)ENvu7Ykp{RQgraJL*WGWCQ6bp+%eh=vl{910fvRTPh6T~mzz1#zGM)iH_^`1i9Edl}Us%RQCcimiMna-tgbjS1E08UlqNpy#7( zr2;wmMEE3lMTw=%>mL%?DHbOmiC{KN3au~nCeYxgH^CNii6(HtCFbo4uQ~`b=0KXe zoqXTryJiDXylV>f2_ouEy$3Fz|HIL!WBZb2zO1A$Y8+QDnt}(ClVqmw6qO=jUU@cPzv9h?Q)RUU>?~6>qvkYY{tr1IN7z8BLm-OH zv?SG+M3`n;0XMMzWf#fc#dR@G-ALL9<}S9w<2P5w7(5rFHrkp^5m;HUUHmNw`XxTk zMe{~0+fmj6q2<;rTJI&kU|20$gSC22m_hU?#@7}&4Fg|?FFzBeD9~R#7p)undUhBw zBY4ex2L`2}6nTY`slgL_8Tx{xgMiN|i?R#!tID~CmKy9}*)hsvw2y61=y$#WaxWMP zM`p@7gF%fYDppov8Qqk$))ESZI;QX{#5aA$d>A0QjAd;JL1y|Z!rW@_kwn?lX=-Dp z7mcm~>f^`3;B9(xy+ic=rw0a5H^|Z3S#|^VzpJY+sYrMLOy6=??cY9)@tir zqj#bDTgK4hI_enhW6Mp;AcGc--{u;bkvE5Mdl{%4q zGI}4fxSz6k-;`<(3#nW2rS~p=U-3hSQeToYj_?wPAtDVEq)cHUOIH zVsl^&l21{TjeW#~asowwYBFdmF|jsWuyT*s)MzM&XX;=CE1MmW7`GA-!;qZBFs4TU#S%I(WNioQsGeef;RV*kpVdXZ1;SJe+Nf{QTubei zigwaS1DPx$sjW0p(29#NOgFO#6MoK^RJ%2)sno(dkV(iJT4_HIH*X_`;{h;*XN?&N zLxH!iDY<*AQ_MUS!h)t!wKr?z3sERtB@P&C4T}~F-H;+foo73% zG1L0^b3GH>dQAeo-4b?Jc+o>%Q+=m#s)AB&xj~n?Y{8>vD|WjqQtF<-02aDu$9vQR z|DvX1!>#zmbZq-oIkDylp@(mNgjivT8U9;3*&r?1k~Bg!Ya;^pORnexj;lanh^bw3 z@i15~Sww=@UkN%%E@jK}aW2KPNwIFSm|W-?Elm+!X1J4jitP&xcwItxzBU`~B%u(P zjY=Ddzq2f?VRRD)1Z2t{)4nJ90`x(kKRcZ?!WG8AY7v52V=pr-Fn)lV(AF?dpixnC z)+VP5S1*1E?ON_tEoJ1`vN@6p*yUdUIhN3pU3BPXnnmLCwVSRH*0HD2f4&IMu`bUg z>!z@`X{}#&iAIX;iQiBI`mXdv&rVPuMyEEJe2`;U$|SYAhF%r3kC-BZ+Qzc8fm_)J zJ;b+|O10D{&ay~tPA8kwN!lcSp@6eYOQ_l?yKKjR*)UuP*HyPFil6#4X*hNCmYHz^ zLu0FtNj%CCqxZ~k(KCB~gy=vJ4NO1}y^g*>rrq<}F*MjUP4yjga-TnFrx}~2bzv|p zTC|MDIr?M1=nZ5}i-b_8jNpZs05KqL(8oP(yELbD5%}|D$2@BPfsT0$xv?`~BX;9C zpV4L0N%W$$-{L3ON6bS$A;U3v#8Y6+noEDmfEaw|A*SS@hoHhjfZ{P=_ zxgp7Exyt{K@Hb(t$QOWv^l68Bm~|#irFL|Ui4*N<5bazxl{$e$;^r_u0PHRJjlYl9 z@mEj=QRft=qGgG_>9|y|nNf>ZL`u^ysB!y8IMt^V6QD2+tQ?p37kNcZt~<_k3k$ zo3PZN*$^{MGiyt_?24#0_G9S3~tV081u!yJoneL>b$}vLp41#S~ znlh5uq<4qrQc&?fAvbs3CNUz_^eCa+9ur_%J!pipa-5MwXCay(n9MA4p)# zWJ7+inB8l&(D=hF6B>F0c;Ji}dQuMl8Z{zq`lj1{K${-?6^g$PW!M8jfHH(>%en$T z1K&MCtCUXk2sbk&G}@9nHW^tH_DK3+74^Zd`5S0Gq&i}2=wy00zP!}arh!dlv8WfbEXtuA_dCB z?@z}Lvwm`?+ITjem>cmG=CJq@ygr_CRrsAf!p#((mBVl95o0JHKrw0sh2<6=h9^jj zbc@ zt9(^YJ3)b5Y#;wS7zl)!*K=eG7}5V%Jo}uP^LZtbdg>^tvS@Lx%ixRm`r9aw`T-k{ zMF`gf=_NiM@CSqZ3ktb#@nDj;5)u zplB?+>n&_QDts2`RR30Z`PfJNBoyQB33w3_SEqGx21)MoYs1k-9m|)ne=kEn@TQbd z=kvGW#453dx|0Tq-iPR?{-dtxr&UT8|LV(7Pu+roKtH8^()MfH6VI<7px%LH=Z4$Q zyr9*4J~!#Ds>XL!Z%pi>fPUY}5KoiI(~NMa0J{E(_6}IG_y!PXZB-_S5A&4Rbzi%a zZg%x{KVrDq73T37179S3#V!R>rrhj`&*HO1+(6$fo=mRR(R)lMy3^k5;%@AO4$k5u zyQ2-eD%zCT^>0F9`h?e^mh3RQJKl-+MDs-^dfmrxP<&Gha=KJ1fqq7TQTR%?+TDUOp zl)RGgDZf~6924uSDSXZjNzs1vz*s_G%_`-<6nn0(#&gmP$AOJ@2aox65=a7IFKB5yTPXZzr~7u z0$s)xLiI14TD!j_ym0D2_OFY0yAV+VqsdFfihw7BvkS3F?|vjharN;$GFWj%G^Y$s z9p?bQ2eSs#bRi;6qeTWS^$WMXx}X0a5?Rb!xb3z5{5QHA@(VIIC5nEmtCZ@LC?{4& z_=|SZp1yWm?9=w;op5+MA995!c$Ywyi!lX}j{cz?;!-R6gw~k1f&>YToDhMvI)MoO zCL9p#UX05u>tfON$UBRFb1WFlussEeBufi%T2Q;6nfMVD4_a~r--2{{jx{-2Q#|Ge ztCk*Bh)v$HukOeGTki}tHbWife*j%dQ#VjQekked6g3U8NUm09JcZ=;5W7mKc&Wa?<$aTB5al(wgcX)6zwSJiVUiM zM|xr=BJ@Xu#TmAW7ZD@go7h_Vp!=P03hb+z9D#3E8CNNBtwhP7Q*t97o&rbFmacVy zsnx%v$j#{%3P81}K3aM-74)_Js(ID9K;N><$Frcon^&C;7*~DEYmgLGQWN#+yt-c< z1cIyJ3ne4U(`f{QrN>e$#e0|g5Of!U3Y*i>TXiduN#KP3z(0n6;8QtQGhaf>HYy5V z3XZMzkW)*E)_Xa@`|Ko)vqCK;yg5ZLsbt|MzA_fm5j3ql4Cm^sj77YNRIVmIAO20L zrVPvpV4-Tv&4nz(Tv+Bufo(GiJ$@t3zzzoYK-djSXb%jUIyiHVqDD;B>k6N+w;w=h z<>_`9D&S$GS2yI2k3Ko2X*-RDa!ShKLSXtZu50Mj2%VQxus zb*VS9Gz-_d+0Xo6WWtOG+^IPK(AhoKh& z(CY*J%P!4^^im`B0`4bWA3_`QC8VQh`{H+3-H@)dmh_*reSKeTSJj}(i0Ov?Viv93 ze!Fem`N|yu4j!qBoc1KIKyUc6s)kPf0Ebr}R9cc9WuKEu@Faf_A^MpjP0aCLkPWXI zls-MKb-mHhkXe7isNTx@vJr^~T&XkFfo!gstuW)^E>Dxi(`=dPIvNP~G?_ik=Ea_) zCN-w2?_`_nj+yF!s=0>A^9(NgOx02~*Eo5e(KW>24Gdg7>3}P0(swRvy+5ix5QQh> zr0?|k0`gA#sQzop(87iykF>eSFvH9iQ-+f~UW=!}GFN2iHG3M&%ROJ1)Sp#ZCP%u) z&qanAhRHJxu90(*VTN(?OrvWk#?unt^6$$L{*bRi!7M{Ni1}|j97!FvKTx8=vJK`} z_q&EOr!~nLRXWh*j4nLy2shxou`1GiVW_Krt-TG9MvvU24e;CU7^3vpB;wASuhD4z9~bYXz*LQh_jj2w{9b)|UDl zrjH9({~q!UQ}!d^;li><&|#SDNEdfS))i5s{}BmE2w`3p{i*hL@;5L@%e}ekJlVA| zdcU%a=qhWZ8iu}ACnm$}A>LcL-RBHCV<2gU=jxG5_DCk^kLXS2$e}?;R3Mz+g=}(P z9a^~)DMZ^Z1S4zvujH95^IW3&D$Z@rW;m&w6&1J3lodT=U_MlRJTzyAtTNHPS22xFC zGJhE1iz_3E$2Fg}Piy7>7=$&%Njgy1+O(tkdSDM?X&u^8esKsU_bK+EEB;C#wG+*s z+7aH4V6B5T7w&{bDLe{6ESD0fAD1-}O=OF{MpkY7N$7-B9~u=yru1>0gx_Y}FOvMi zg0rlF{USc`yiiIK&Ot4i0Wl1=5-~ycX$*-aqzZ_qjR6UiUL794RqE;eaxy-YZm-s)1Ips^{ohh&J|Q zG2CyF;^O(nq~0V{o9XHhq0~$#TA0#%)03MXUfq9{xIJYUR$s98_rEDD#4~v1eYYN{tC(%9!Ok=V=@)_=fFB*vG~P8p#M_`|kWUKM zwXp#+t&ZJ+@$O5#){ji=Tz^xw*=_I|+7J_C^^40Ns=X?_n-&Cmr3b>#w{4!aVaAfU z&jQmgzmEukXWm1JY$B?9*nKIl#N-ad>crOdb_e>oFNLjdb^9Vgx267wIYjl7%OARo z=i3&=pVKDDb_Rdi-gKD9(v(a=)C^vABH+&roF3QD{*pOirvwn@XYulvBV808F z&G{a`!#V#g2W9$ekmlxzsI$HYgC-ZjxesYVxsBmgkJocdTLea7X3f8Ll&n<60|?LT6YQ-(Gpl_C|;8 zjolcD2jabFUWz+hf6SD4u*6iI6-?Z>er$$z%Kdr7?j!YIn<{sm+ePk^^(Rb*^V+Vs zQ?BsXBb5;W%S$tAgJ)icG>!L-v9M4##%jvU8m;G#i-R1t>(>Lg@*mvF?qPs>t_;rl#x?ucmtZ+HrOxbpe za7Deam)|N}w|`mw>)XlYJ{$YRKOvbF<=ObZt~ds59ftDnwG8{!L~^}9?wvoqdKX-d zb(0_L{TYUk!Zq_P%~fbC<-V8S4{Z4RG>78;#h^ED-QSk#P-KyAIoqkuP=ZsAsr5%ZQ*}B&ZSR@$fzN0D;7S`AuTdoprB$mG$psQ{P{f#Qyl?;y-t6 zjrA^g;qklj*kaZ;a+!9a{ejLix4rkL?aMxOum1gi#a0R9y2>ihcL`O1z* ze8G`+VP~6_(2h+fh&HU4BU~}73><4-EEF+^O;!3}+K&(?)Gp&cV2^-MlJ3l&lUMp+PF}H#W*MdZ*ze`G81vSe{r|#t zFxl8NFxbmLF6?J(_r|wW^_|we?;PLWYquK19OP|Dn%U)wnpri)FkwnR_m_uV<{7Tj zDV3O}YMA2?CU7GYGDIwOZbfd~Aa*t(2AASV=wTx4&v=5T386^q@wSO{<-4)B*Vw@` zAdBF(@&AG&{|TBF6_|kd#B=#>97?W3fUgD_M!aTVmf-v@+N*^|xc_f#R$IJxe!br~ zTrZ&n9r6R!j^%V4GVmgxK|y%g!T6L%&asD>)~+rNVGOF!sCmX z;Xb!vC(#*X1mrUaelz@Tazv}2>NnU^3pum>itV&sKbw%=ldPa3Ix0P0{p zo=C;;4+;lcVHXxvq+@QXBTK16264=S(@8cVX}oJND={anHM^oA^pa_HB(p|~*QM%|IY4O%_xmAFgo%Vr#cA^Dlw zNdIJP@%m~O{w`odD{pSa!CN2Oo3{C$X5;C?|5YOwQL~>zcldG*-ni{do!+$q^OSQw zQ+P9~yeL;S2ESP3UxRZR_~&T*5bz2Dw2tMj@J0TGx<9BZiLI(d@Tuzzj>w4b8U^3g zp_|-DOZ^l2%PC|N3VWSX2NlAK#9NBpRE6h)YA#L>Pc09Az8q|q*CF)e_?Gx!)lkZS zt=$Pu8d%8g_B0u*=7vu?Ko5NlAI)=}(lc%k3`W$zKb5Mb@!=C<`niuCc6~hqq3OmD zzb(}1Aw#xyJIF-~a^X6;!PRPf#5~t&o!X(rfnilc5fb1%=zT@>!WSD_iDKsbtn%F( zO+n|`_}x&HqVm~LZHTtg(mc(4AjP3*)2#Vgg`g$}a3R_4UW z%H_S#mpl~$jM|1p1v5KIPoQy3565*KvwZg!>``Qr4_}PEcK6gVkXeRx{YcnB+#SC7 zRo~#iXlyiv!W4Co)0w$|_CSk{cZYf!ExDA>0wGwB^zb(e{}A0?SkRmO`_LmHdWLlo z&Mbc;`4F$Qz*u{l!JX(=t?tBt%W8YqJ8fD3_J?7HdXzszXE-UuA0yFxJ;%?xb6f-k z`3mj+C@G2hqut?)QQZ)gD7_lTt_0>H4>~eG?=WMqDYl9MXx_3(pCJZw4#tXJUERgk z&}QhsC^SmNZd>^�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
  • Wb5Ag_w3 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� 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 O^*S>R5T&}+3<{NIE zvJ%mc9Q2|u`d_-Z#K#N9Ryu@YTdv-eVUFRQ`;qTXS$G9p{o2k z4|X|rvK4;~@FvSUk4Oo;hQv*6PicAb{bwOZU5a&(YRnB{Xe8!R&Svs^`%qbZ&N!9F)$pUC~$t(5;c&m%m)<#~zcbsh=(hzH%Cf?%=#=P$)!r5C48 znF`iO4Nfh1)&I~-Fj!|47N9Cb>}k%F!qh3HAePi%sf|5aT%DcYb;qr5$(Hyi6UVr| zB;;nvy|kjGJ`1f2DXJklr?~r4*oGllLuK z2;WcHZ;+nqoP+F&L7(Ih!xaG3Ao4yIOlbdGUt^c_wl8m+?HJXkd)4=HtCum*>euMYKB?Zg z)gLLY-K)NrTfHQrYQ&#Xy_6C(KM`CXGCitqC$_opiWC9a&u&eEtg6Bp#H8&aCZzzE z{7FJ^Cuwa~0QeIYc>FUf?H$E2B6-lWjPtx+uGFP^ATS_uo$J#^rLZ+qt~-j!{yUaOlXljC*wX9_&5oWsArT>$h|&oex9l~{_)Sak@& zAVVBo+Kyov$J|^EZ&zK&Z2PWEtr6Zk8lfy+^0tqgeQ9Knyy6yA3p0OwRhBw&U1n8Z zoCD$&ag9hNnXpdJeTqgiXl4W{L`DD7$YQCtb_Lp(C#-uE7W^rbgU%3nDQFF6D0O`y z5{|S;DP@1JIMk8907`B*+NIpabmEA!*`zFyT zufuN@S1XrRF^wO(__K&9?@sah8sg!DLnUPoA!G=gl z^U1y?gRRUPtStJP>-x~?_6wtjeAOf2+Pr5@CZKldr9K8#K9A;e^$>Pm)afseq?0fa zd7m?&9BUw0pk>y~bNEA^br-ha}+Q5Pk%IV_#CuqxL1uJYZjX zn>+1G9~09TRLg7Sg@#nV*nYm-dqUff2e zc>>8+mX2!#k0RJVPWPo7NC~v2qt!^3Xybf#H}MW4AEh%h*<#DbNUDgP9v?tI^f9wlYyG^)*!{>gCs~J~9BE_Dm=@ zz(MH=^wlRY_(^?r@ht0)_+`OXw+b{!+Zf@80HHqAWzlGr^wn`-XkMaCkSu8D#a zC!e#^>vpebmTW_5vb6UE+S}ANr;%QNs8m<6gx)U=>6G@KlWcFPgxMq7l?)YVXozj~ znM8<%!*dCar3XEmR(CHZ=ObnEiU z`AxDMH|tU@$1U{g!^@e&r$`v2Btd#|oI(gz`QpD5W+w$LOmV(&-q<(_paK9t6=pTU zB3%n&`R%V0%YG%uT|We`ktAuT13PDv_wD*2c*^^B{SG`JMS4yD{23jBW4bAP?x2wb zE#_&ozY+Xk?{=1Y2%yCX+0~g zv6W_VoQpdzn@Muic-cI{2_!D&SS7Z;r0w$ZH*^e|O&tj-_DwrD&E_o_@1*Cnlt}VZ zLMl~!N+t~-YrRqN6mRVXUoIER=aUjp z^%9LWjecxX{#R(a^LY&EHyWTc2|kfvmy^`BwS+B~Fe9j8d?GY9x*VQQ+T;r&A77&7 zqp0P7UevOz8kYV|*T2Y`%tPcwnqkLJ{8hoXp5rVV(@>NfEZ3_Rf~J|{w6IV#3=P8P z?02qBv$+V%0toAeZRk-N>J*I$n%fA8EgRz$<(_)t7OL5i8Y`0f3A%ZD$T%@*Vkz{w z+3(8%@S4my-2sIXpd7|APb;*Hl+RZa=2ZQRq?0LAVZ{a?MKB_R)TrO{Z^2%C^Y$)g z4}cdF%`O2D*<5~kcM^Lyfk|asHIF|G3Mr|GrM48wUQpanhL*0G&H$mRloCGb<_jda z*Uc9IFIYl}AB4fM1prO_g-80@==9nbA7%cKKk7I96C5uf)hj8E6(PDTjTPZ7Ybp+} zoaOmw#byBJujOMBQ#2eV_NujH<+Y_KS8fw(Y>X80Iikw9LROwR4QsDh(Rf+Jg*r8{ zqA?BkNcWsR=E|qOPS_9OdT(NrX0K@|nre2U)s#fFzoFj}e;(UHQ`x9nhd3!Vc7WEl2Q11Vc`Pw1a&~txPXI55`<0 zIN1q27+V!)uo~(_q{WG1YtRWi5j4kPa}@1NIc{qqKs9jV(vc9U_XJ52K1%{5jifaX zFqAEU2PK~GSYUHQ;QpWq0I-!ndT(>}G}Nfh8G-MTo_!Wt83~lkFKH%|W?{RtO1^{U zPt^P?A_~JNE$r|Dw-ZQte)oGJD(1hV4xr3@rqdED5wX{w&SHL3oRTWDdlu{?RHZ10 z@CERHRhI>Um{M4ye%)i+tY%&s>STOO)$=l)m0c-9tYepvg^ z9KvRiPWKj34VA2}fxq?sVRMQmjk*gV{nhy6ckXfv`~>&&&RtR0zZeI|uNS!$yNGRSp%My`=)PiBS@*M9~k_6Gf-Bb%fh> zo}9QXjWtR+Xp+mdgoF?FB9umF?Fvo+{U08CKXm`(%Oe*-n!WE8qv-m7EJpX@_sr8r zDkfcu>9+WTe*{@&&ksp`I!>=JP4C~uvJ;KE?aaBpbny~0oveLPty@FGpmU&#ld5$- zdYoV<^%Y;aWWiO}+B?By-xtYC>o!^3Ohk>paX)#@d1$%BiYnqKHk728{(Q(?PZc1i z!ScRC2nF*Lnas)9BI|yvd{aT@RH6Jod(=^c9k??8lwxWKRos% zRw^bbiPX!;f127J`YmuQR6KY{FYsezJpIW|=T;rkcTD3SXjyxS`^^OAeONub$o+iJ zOps`;mHPTH(tjJhHM#d75z|%dudAi?wm%Qc+ZW~D?RZYqw)m}&zD`JB7z4AQ7r2=~ ztI?6OQ19py$vE^0GI>Tlne1IjhMWt%G7gn>2damZ$aNG1y@m#r>D90DMn!7N<+m$JnARaZ$J#MEM#`p?E}> z!sdot(p_DE00fL$6aE% z?lM(|wHFSpJp&G=siCFJ@;|!E3D4(!b*&sy#{~|CXUJFRVEtMN5CDDk0S`cx2t9_8 zAc^UCtD8$5KfZ15ukf`OI58F%RR6b=#r9qGNkkpSx~07NgOzus;|2Dv=adHl|{0&J=+nPNz@+Zz#P(X$PMI z9QSQue2i!CXo$dHkNdPTf94I43|9i7lgpBu+vTV(d~yNzA*Jd2D`5JUKNSzHd!A$k zf9geZ`_`~0Xs4>(z|80}PwYtXnX92#WCT5afk7%P$}*sBY^-ObY3&N_2Ha$>JB@C1nl7wj@ZENzcN5}Z zz5cLZc0QY`UThdY38mNLp})9?0^-b^37(es(V_}GRFD7$`|PgY6;(@SgVTuUcjgrp zBPkaP-oa$RMOT`Gril3+r<7Pph8nyu!%FXaL_wbkD;XAUuUi~7eZyy$hA)nqVg8l> zCa`S;{p&3oSJd?L-|{X&z5D6c0RJtwOM<=@h<|l1bT$47{VNX;D(6C>NDc48F^fye zKl2A&&K!T8=(@JO!5FXZ!rCdm~k zijU>vRpOYWS^%%=AApA<~;H>5VmnmU$1!@x~=k z{VV?}O)Q8emPK;qt^q*YH45O)vV1d8$}q93GwS~7uX{<8IxW55pf}9R^%=eULY~Xp z@c6~f)#)LjBX4f;ZT9(Qh0K*$xrrUZ)lNy3Qb#92tDmuI^pxtyUm_@Iw(#okJFhD(7bt@bb$RV^K}JKSiV*tMfcrj7(q{sq0_mP zvrHtbA@B?b3w&IkBGY%J^kJ8~_Kk6HpW_nl=HKG8227<_Fqa z0v)iGlt{BqHkPIfJ8I@+S7xisp7+eH8-)7>zRFOp{#l}`8p#tS)$plSK#4+*NFw>c z{<=^uNBt5FCxkE2nvRrkTFFI`r}b^%VT}Un$q7mkDTH_(;s`u#*WTklO zj|}$uJo;qm^N;CsQ`>;Y0Ng*bmW93RY-KUGfB`5%EV~Y8DF~moU04dr`x0HLy(kQR zf=S(rmJ5EOcX83s=!?}XXf#uuRq}$K3VCxp9Oz&9k+e}f=J;WY?N|@~XFhRX0*L8& zp-YmMD;~5Oeosm_@O?8$Qlfy$FlNaXV6R${4ZvS_izF;6PQ^WlwK=??5O)r)A?dph zAu=dNu{&g*Wl%xG<>)}yauKDv`wp4SGSq_btc#?V&FSj^vL3ERLgsrUffoGZMj0KJ z=wm1WIHD^bGS?DSss6$zOQY9ZAb3^x0>Lhwl3v9e{x$n~FQlRj>8k7_*aIzkR(rMS zF&Q#zQi|;co!h{7&(1!|x9zNG_BLiB<}yzgi|4Dy-q7Z&;T-GL8wE~;-Y86QiV923 zAAhFfkR{^)$k6eY3)S13_+5od?J+yt-|5kV(ncT6SCvp+w4(96wsiW@E5%|PeE{S5k2a3yxa zEWHEUF}Z6AbjnF+i$4c$(aD_In@qW;$R!1b_F4>vNF%4OE&hk$z9qsKVNGR-tOJ<_ zB-o~vg@EK!#Fu-y+^`>$sV200X;F@}NG;337AB7b*6++H+66GYVXrN2GWVkxq~9)Z z)Qh5!lI+0R1UviH=M*Zw=%O`3EV=x`Yo4)~0Ruu=`K5&rzJCN;t6Zy{8@aGlFE<0I z(1Ms6pXhQF*v~+BJ_X0pP3A@nbf9yNl3hg?aN7w2b+X6o zMS9kj$rl``{Y-?@*${fvrM4W7_4W@<{W|GG3b6{_}IN;h$V= z=_QTs`UjOg$FkQ^Aj*!HY zdq}?}P2K+?&E@}xG!u@TM(vFOVDr_@hXgcQOzSO&gz!3D9VDN0plAlJaAk&p1K?S_ z@3sm(+G2jN@=zjvt_S()&}0QA>5)^NsFEq6sbEGS^;{qZgF&-Fx0%P8eV5$pL1V#+ zhaa>>v2b_@{{1q;eyd;xnSm9GoNTSnKK<;4X{dWvo(!CIpC#(y=W7bFV0BZRdU%TB zT=DFXiGg~5UO6$gn8%M1eb!Jf%s5)iF92Vb0=jFEGo(DmP03tq$)d^CV!~um6;8V! zi}(9}O3mPd(2p%#Lzi{B`e90rrsT zl~HrZzjC#FVIl0V6K4vphGM0&w73$x*l9D(`K(OHd25|777Ux8QWD-CVamAo3ly8F zR8^nKEkHyXnU_lDOg$zh1D8o)c#eO|`<@!)y$~Bgb3ZuA1&8?L%A1$>Pw5po*FDp! z^65zLfLoX!R9#AF`oE&>i0R2uZj`xeeTq21^{}i5SBKeQ{eb?t_wgpjX&Cs|hBdGH zig#BZvAt&)oKuT)^c-(>@zu@RWxw%|tZNK}X7tKmP)l@EJ!SC`e) z{evB$sqJq+k!HDe0>aX1wNp|hKKhg%M(bdkj*@F{yqyo+Q1I8viiv-PmJwGGI~h z-yt|DIWVj)Y#_hqM}}apn0fL}D3ZRC##y_RGVS#P=@=ZiXA~9PuGgpo>Z!Wf9Qq~l zTKL$SYpc>w!rOEr84Wd^xcvT1@|4q_fkT8~i32MO`!DQYZc=ct#o)iKojL{=R6_JH z9NMp)+OJmr%5bQ$xQvIY56p+2ku|dXWalI0`5eng*y~t-L}T<+m~xS_iT-Y{Uv**1 z@(wrYQ7V#OyXgt7`t;gOR?+ALbv!c)Rzf0}>$KAO)aWN`z`a*L2eb|ZLhq8SW)7e3 zCJC4F`^b>(r84!%)5JrXj1}Wx@rqh2hN^0R=V6v{KbLC5i|h4Ql)@qvw4c2R7BWta za$J4vYi}1~E2hfXuD14Ts13!>i*Awe=lJOYZMWJhc;|aL>WX>D4r+w1gMN`)5NnKZ+{Md|5&F-ZeKb=G z{raAoA#|CIyR9zFjAy$K|B}}!94m@uAyiwq^P_&PEQF+#7|%L&e&0UL95 z=}i7QShEN(TjoIIH`z&2^kS-!W?VqEO>MDzq(}1o)G4ZG(%T$hhoi)nLS;z-QL1|- zzQ{8?Ei>HDD_n4DK#$N?0?r))KJsANQ_>QYJ{w4+hCvPNTJ4bwd0$;P3l_bQ>PM~j z<{FBxp|lvi1ySaq$M@=-y6(SEB$+DSq)SOGc`8 zAfOLq>cc}Ltp1R#8IfBRM4L z@gimm>fWm>opK>7VsJ$Slc43DOgr~~NIN%~*6rsf-|pvr?WZ|XKey5T|4ToAk#od; zZc3OgCi4HcpL9-Wdv6>Te6w#F&zya%eM$O0+^7B6%U{dy?J-|p)4u4&Pyp?u2=cjEPOrHUa&9ICi?@uC+ z)$;PMQN@R$ivF9-A{q(HKHP`Kq{P#Z%-xP$$?gL#ZWWtEaNRDN0a`h=J%Pg<-)A7j zIfQVPT6&I3vE=OxBxbIJ^39j@Trt)R#Y%=2oaqvq1+$B3aFbbfBEv84S!qd^$To(_ zPTFh+*anaMR&4`AMfn!59_-)KzpDwWMy znps^U`IRx=&oxDdO7kda#RcFTy&Y*aW_2%{*Y8!hkb9EO;xq68pPd&)6Ta$`R}RmO z9Ixo-3v9x1(0DS?9 zwb5e^i|*;Sp>pFX&oGz6Xbt`9u_jWsCK5eu|Kay=Xlye7`AZ^ExpBfXynak$?Y>UF zUEPUg`j`JoW;T3U@_;iIk1Ei|t_-hmtl0pu8#KSz0&34qrW%i#OOI6J&25^hnpD!2 zZ3(j=rUya#Q2F9Z33G{j3XjCYHxvHmf|T%{GU?9Y(SW9u@x{AWrNIPDL5(3F|j zf{tC~#zE5l@m~9ddnu-jzVMmqeq(U-rgR@FxSX<@OfxmdGu4NMux1F^K!|JmsO>lF znQ-=P^OXDhi2M71{S_KRhDeaxvh>wOX`|Av?{jEJI4eFbx+23D9s>rOoMF!THA1Hm z%4v`bbn(spKvGnQp95BxD^-i6BGz)RJu5o`toDHUKW-+M!aGf|`>$=wC&)K2Bu-0l zAY<_Q9SJ$ZbCHLfDT@iK;o+;8LXmL|i>_dS4iZaWHO@~Z0>oTsFFkpS?C^ou26mBI zQjz_sg!yxwraG4Mp8xq!TH{dRAo{M=eXO_CD{f|S6R5m-Ij68lT^5K-4K0JYq%EJK zTd==wJ@cb7mpTzcl=+{(Fm2;^?aA$dXQW_%-C80>gS1Q1qMgUBI6C}YasD`eWZ<5 zM6y_I8)>428MhQ2_qS2wV4^2z`DY(C-g!3j$!_n%Udh_~qrOqHN6%_Gr&J;y$iYO# zj@vjdr?zS5Z?$){#yvx97sya~johMkjNGD@<=&zuMr7Qg=3lwaPRKr%HTZCpx8k!< zL#2Pi7m`6pstj%x1f98r&Al7hTV@~e(zOR{K?N;=oueqaA+R&4bTu2@|Ax?Z=6mS9 ztjx&vh8oqR>X~K?C6nOhI|Y&I9c^#lqAUtgwn|qXh2R3u8>nHw4{@@viq|<-@%m-c zM}n-`edUY$v45cq^sfKfeb*s0C^Vg@Ra@;ib0boBIZXX>Yw|E9oEgYYId2qvf!s+= zWO{`Q<)v1%Y;(e6%FFn2YDJYXXx{%FjmO*GE%NEch~gyo-*_>qN9h*4=Du!yrmEji zuhjM>9OI_8b8eM0rIK|jH>b}XUY~L4T1%nei~eP14f>_blgAN29*Fk>v|NtW9T7RD z+~Cb0mybPxDd6aTGP*{Vx?WT=`k#WE%sZ_zib)cAf31?pC`CzKJ``nf*;-U6^3s%| z;`muwOXNF%2X2D!Lt*9Ksp1$^#NhG^xVSs=Rn!`|FmfN&jHP?g?HP)<+&cy`TxQ%I zTdBysGb5x_hbU_KS8gHLS$n^984gL_^_-R;bk(N|8uNZ=yMQ%@(YaUJz`Zh{W}P~6O!ao%B-AfthP1mv1J0KF`p&?gK!$Ud zRxu_0e3)6UKu@mM9v%p%;(90bRp%}9Z|Hnk%k?_jT;kDPc=Y2HLIAZ30W{sDQv(TI z8dLB@_~?a$Roc>zHUXFGfhJKcvtYWFPhf`I11bV~dq9?4A~v)?efalE;Nvc-Fg8^2 zh$6%>g7I#662MgYR|vu;^DNjNjByjg1-lu8@E2tGHfq`_q!l@4WDbNyA(Vi7J83rt zxqAbedM#X5X?{_q(jrv9jDxO-H3rHR?F-p=#}jm*5DAhBK+PGFLI@YMDLxW3Zt1hr zY+Eus{4@`anH#66mA1G7-{3`8>_ z*F`Cu$vrJXKgC|m5C+Yg3{G5#ty@T|{qW#)pgHAPI6#VqMN!i_hp}aQOBKIkG9$f> z0dd)$i@v5eR-i^C+tM}5D^cB~PMC+BKZ#n=D1S^v4a)_e4lGxTC@MTe@gzY#6k$qL z5oVHeG*0dg2mz)#MxfgfYX0{3Z;^{9DXYocP7ShFl&3K6p+}`BQ|tAY`4FuhMmKL^(#m29 zlW=Mx!CKxO?#&ql!CZG_IY6reHG)2q{X4((&bKb#T9g<=RUIwf-aGCtVUdT=tk+*b zX^KQvwu%P@d{8ORx$!35ZX2T2q&4Rv=t**D4^oowocj^j)b@`R$=%e|WOnTXkzH?R z++C_Bhc2*iPHjQaNNE>-lW6<_V6OphP)?VyqT>T+dbw5;K~LQ>7V%|`O-@_b=>^Ur zQ29KAXO^31sYTIExp|yd_En6AWM7RHsXa!X1eD6Iou`3Q0p{zWL89Bo3&L~ZKxiPC zAI7PZ$)wd29jmwYy~#9R2yvf{5=U3&)duEX9KmwhxMB_O;*O~D#SIA){xM1JmrYy0hFfagd7<(Dp}tr^Dm^54};eNcPKo9s8;`Ul`Iuyl9ChQz9BSaKe24+wPEd zz`WaU9-#?n&qQn56Om!chK2;)FN!sU;+~u;+MT)W8Z)qnsDjz)cyrqwAAq(Wo{IL1 z!mSWw`%RbhKo#N}6K4HVB~)^1ai|pTSGz?3mGhRW`ldUR^9ur9ocC%(2@ie7g1POH z2a`~86781)m)syw@=}dJ2`VNGv!yl}Yv5BjAh>9){XAs`Tm45M51mW*YNYK{=iZ~D zYZ$$<0q)jtCOeDocPYXvGEb0=J=ZVffg5y>2C)$!i!}R6)hgB686eL}Itw&6z?M(i z70RXvSf3_g!8AO_peEc3b)E>NqhkNDC%V#gD|ZKZ9M9vKG}dc|?x_zRu!IGXwS!R) z_t{A6s_lZiG}6p^Sl2)OmqP>$ey1cX?mKVj@05#U`Pi_ys22_s$DVFjW^9m#4H6N~ z4Ffe@hBG%Kb~Kw=CgZS>Ug{z7LmeY&W2gI#lb?3^&TzkR z4zgdq)7@`6XGUg!Czc$;Z5V*xa-N*|SS z{ZPD>^cmGFoE{G~2k=K%#@}A?X{(DaKe=~34P8A%{*G&nz>vv2uvHZV1?nQ(0M;{8eQi>L87)z&mP?T~mz3HOOldnP4*!85($leLyL zT8sRpmhYm6UehRbgr3d|J)T!KH80c{3pGY-Hu#ngvw^9h4TQ%+8@PdBD_1q7t`4oA zQu~RNJv)AxHZfN;A_fagZ_~DNgRl+R%iPIZEVNhKeI{TiDK|s6^EPd>q|}f- z%a7K#SZEJgAZ4W~q1Kep>+0Rb)$fkRah3 zsE4=E21%(QJE=$Bm~84Pnwk>WkrLRR2<*GaUw1t76s_6oTb}I%_NE3}X?j5~tdzZv zSg&Z!9^djD3wDUr0((*euhVRs%Kea3yR?j5sev8HF>S2-A+bBP3;|UsV`nNL7fQFO z+>aRYbysRw!&Du<4pOAoJ=TGI_gn|^-E$qJWHz;336_pGCK0O-V*;PBBn7`FnG{JB zfVUCAwl_=s8$q`{m`HTv1<9zsruCA87SqA0gOzVRTIOA^7;hNlNWbWo*|IAjF#&aP z2CdUln%1oy>iGo~s!Hm7>(@PsFh9~F20C|1c8gO=*@9^^ZYC8Ubyz&z9QYzd@bW`n zTC8MGk6pD(FYWDLdAnp*-a#hB9jP9DNs-lUa(iP#NM%ZBri-$0LudyHME3^V<-RKN zl5Fq7ixiBqedOVHt)!|%U_a8bB(U5>)2O;K z>iYWl4oz-qt73bN8^TuyFLmUa;y&t%;yeI5FR-g_>+;i3NlBep>P&0Ro3ACul#9sEzF7!OZ&#jsy*noeeeHg^;Igr&bymwAuDN zBC-1#YIeG@Zdd#((@BI%LI7E{9YishOub*GN(1dsb_a4MpxyQD(%EuKWr~DvD4rR) z8FJ*@oykuIdE{I{12&d%PMN#s%VwW1hkM-?X06++ejF05DSbgVMb3%3o%@i2}8EsYWU791xyWp4tzgbK$#xz(n z_Md-9_6yOzvF9e?{J>jKm-{na8#A=SKLA*gHfG4sZtfvCdRAy{k>m^!J1CeW%YbHf zkxIC?*h(e6_j6wsl37o0RCpBT0n`Lkurs|f`f0zgU;mDXHvf~Cv?b%k6f^}>&|W_C zM;V-?Dd+%-7Ms6H+?s0iZx4&!5BHpHXf1NT=uH_Z2r(z6Bh6RAUOx!L9j}r-Gbu4o zz6c*p4!-tGPeM!!65M5cDtqL>b%pN-d;>~?v65iietg+_ihhz`MTOR&+^4#U@XkG_ zsFy7AoTAD(Cmd0y5YP1CT=9&!5onLCpD%FL48LpiVusT5EP509zTsIEd(*OV^CKc; zk_yfdD?7Pa$9x(h<0>h~v{VtRZamRZrZRQo*=%yjBx3?Da{XP(g`NJD)~x_gr3Uc;0p;qx+L6_BM!gtRY{tEnw|oosT+M7Q)z zWDcAzN#;wEPecjT(+~8|_Q!#|UnZjGdkxFgt%@^eQkk`~sScJ77 zQsI`Obg2ZW#5_qzG!s6kG!Q;ha>W<)H&a?qEG;i6K%%SxK)L?8TwnL*R)8#MrhywU zJrSnC#y=&;-doCdyiQfgp?ir0Z1o_OE_1%-z6zAh`oC7zznFDCMnnvW$C12Y*4a1zds5mSk= z(wpD`;Sc-}>J>(ij{Gb}K4{*3pa;ULqGlW^n(8Ie%$u&Ene86VDR(BN*;~5$>MdP2 zT!_WU&0qQ8gN2K3{whU&3vRwCO$5B*vw0B}pzuguVEw{7bgoacx4qqve)A!@qU(l% z#63(my03jR%eFA;%C`~r0%$?T`KsOCc(@3l_Qg!{`yyOFEsp;`ucdRmS%BJ{%Q&<~ zxAh@r(NfSKbJJ|z&@`QHnhkE6G&fCh#;&C*)M>2~=AVM5o7%#xN1QOrY+0VhUZq-G zO-|=eB6T}Q0UI5#T4|Vi`JDFWWTRE~Rzm}rz%(%<2ORDdv0xt~j*X@1Gp447_7`lc z;odoOoekrv2AETPU+twSO$`}0%`7hsXI4X+Gx;tEnC1O>KZSQ2I#5G9G&Ds+I~Hcj zf-i)REI+0ESfXN~>}cju80|rG%g>N#Oh6ZumgU`&MUN(Y&2alysX=m+IUy_#a4KqU zicZJ{uld41V*dfm7y7D(X0p<5B7d}|(-*!t8J;cSS9sy#qyD&t&|Z6`%n$HP15JY` z&E>9H3;K9XY~Q1FR|ic87gk8?`bg^%L!?emM<|#t5hnpP3)AH7um6w^eD)x1S9~|4 zIytp7nGkc;-P)^|_KGBS!tmmE+d^h}ue-zAd2V;-*-CaX8;&%L;VOBMAm`}Hfb7x`=fsw`{ zQ!JGs7ZCLUEbd+=r&P7IP)7XXOXv=?n!@H#o3-ykY?(=w3_mnQJ0(MKpBt`fqFB_x>LA=LeVfq(6&cTO+AZ z`ZIqB5DERMd%e(~>#w9!9{u?>`FhYv_7)MLKR+Wvi6y%;me1qUB{=(omt2B#J*jAp z(D^JvtkALi5)RVo+tKgClss{WSQpoMN+wRNk`NuoS~Byfzj~{Xbz$RZXWYc?7=xVP@PbJdkv_HX|04)$X@F?2i z`4D`i!};`^wY+zabkka>+`@E3Rw!&|OhPEq>1=B%!!JZeAC+YFH@hJ{i-5b_v%Y##ZOwFV*X0Jm8Stc9|Aq9>3l;5N*tfMVB$89Yd`5uFl+Uc%-XL~A_J7N zHP_LrrrNK1MKUbOav9(8qes62;5=Mg=rb1?w(?JY2pvP8wVOvSM?3)cEJu{rdzRBz z%K3$sW3R*#F-miMIEyTpHEv2~Bs01+Tiop8slyLJ9{)b7D&<=sAQ#9OJTv4zjD^eoIB2<`~ z&1x1`Y2;jrCbGL8@58M}E_(80k@1UoOGiE#FLAzzpM+emBx_tS6CPW$2_jGl@{2`p z;*vY_w#84OtJJ=@0)K38N)^Eh>2YtTunJDzHgh5w+{3aUf05~Qf^$TOb34OWyF8QA zTODsid?C`BU8_qn>9r_+4vy#OL=u%L7`QV&SSONipZyk36wT&w3gm+AOPp7K^5s_m z%~O73YikALe@ovxq+Mooi#^l+2Zb&&CbA}aDOn_ zv5YQ2FWKuu2kGW(mzZ-e5zptsokx1BZ5R%He6;IE8(aP3uTjy2OcZ!e_t!%R=)rF& z+L>kgip03d45vhJV^I!p84Kn#fl=eVz#ej)W8_PLRRvXn=|9VoxDm@Fc0M}|$-g3fAb$>lbz+3e9UgmutKbQzo# ztQwP6g6gsP%&sMrQmI~wUoR_wJp#0E?*7Wk#cVLsI;^{Fb`)l=x||gk=)&p_T*?X%p=~UP0xLm_eVmB&EjvRaJMf4-9=AN> zdwI%}08Ra*;m~j_=!05?6bR5Pu(K2;6}~x{2r4C`-zI zg|;`f4Vx=Vno?Ese1v3><(K7585=9jcczSwm5$L;xFWhM798JFICf4y<^K9Q zGQxtI3X0S#A@?43;=-S>=+aIfSBY|8st7Kjw~I2=mm<#blX2+2x^djq$rN2oR$xxy z2fzQ~xiZ8RWL$X2=3Bw$8#;{E=fzEM3w<=L|U9a!|c(- zMMA>ZfY&5It{G5zj|B+HQ4wO3dsZSmy=B>xKQl`R5}q)!k!G053?Mws$;{_ui#xFM z=md4B5~9T)O(su5yy$0AqSDp~mFZ z?1dka7uY8nJVoGcu6RBk?+wC=KI>X~%W$`g@U__-#iyjwn@3v3^cszZz+Q6#?JsYL zv^Lc2l`hO{n6_7lX>P6OR?59(>|I4UuXzjezJK#oRuP+&&hnoCMMtsBZ!-U4*HLaHc~;ksg<(=3_|hq=Fjr7;X=I_ZtYUTG z%lgU43BPnnjx*vjFqB3T3w;?mR<24(tiH35hR;A) zs=a%k`r^Y^hrXO~q}V~!DHAA+e7n{;DgqC}hjG4A4~fnj-tdm4DUe%%jQXNXT=~`g zSu&T)O|o|iMl4~R_>GlRNs^LMK?#K|CB;79-XEyi)o7B$@IAxd*%kw#9s?Q`5e*@+ zc@^bV)d>)qy77LMZ6m%&q7KWFtyyHh|8|!9bf>8>yIB`+b#hx#t1nhEwY2CWj%hH|?jV()OI3{aPCu`%EX5+!$c8{G`|=8F-gw0<`_Xj98g;fz+a7m&$FLXS!p{@%pb|@v71Pox zVr3D{klQk4EmLSy~6xANr``g00RwS`LD8d2M@-E)duUFYa0C{1Z4 znKgRNj|@W=>Dtu#$sHF#1KdMu6OLVRoqa>jW7~04c0tREOWf$iX)7-B`gnpg02J!> zqWWB38C*9z{g4w!adev>ruR`A>ee0y?Cg|C)x68qMckg#WUdAo0UFZQAfI#iGzoB| z-B;a2*B+keGD-A-Bmz?1GlJfaAs|lOYSr@G1#c4Yu%AEA z7pkPGpXaAH->l_PhQBXU|mP>a(0+c*<-MkV-eUZf9{v_zr}ENziTgp zN(8|vzSq4+H9$gw3?}PF&Ss3=6KAo)tb*vn3=IyK5I%I89Y7;FWcLc^Lv6MA05xA6 zl`hg&n7OQ7Mr|moaxled*!hH+?I0C~E-3@Dc$Rg9em_*Jh+lN}UQjYMKT)0`^vH5< zX$9w*TP}l^;>;rRD-1z(5g!b8rp&F%ZHrT_yotnMk|1#t$9fn{+n(xU-i3)A_Jh@6+2Mg+2&#Pxmlk+NL zG+fB=cJl&EDmk6f6g{0Hrx&6J6}QNGLK}irht&r{44BaeI0GFP3`tSYyObTyzfy=^ zwmENm`pG{9dK$_y)!>AAgiM%~(NLC?%rD>CY#fof%|@HBgYifE*fNW-qn-lM6;o%v zVDZk_>2RuYYu>So7#$}3rU}h+(e{|`^Z@$ zOgmj8U8q(X6IxPGvx*;t*$%LDI!m*imegjf9#x1bfp4b17H#XLe961GwpC=C7O>3P z{vt&Abh&3+=hDbhsOSx|h%*HK3NyvWU&8$UAOxlj64R+mxMU#t`96AL$xm?v3I8tn zO#zU&3FOGh0!Z?nX_O?do$nU%o_T_AK_rkRR*sbPvp-j6hkrLxSot{mUvm^Ra@95T4lP6I7Kc&E_bRW}CQp7LEi7rfbHl6H3Dc$^3 z;6^;_ib%Bg4DNlG*eTgEn1rO_@^))4^Lo!z>EBA#$ENzFq*9kcuIwwieV+_78V*3T zGOBNdKj2Dc-uo)KmdoYjY7!R$?fh;@vuxoPx)Xq;z+oIo<+S-=cX&ybnfMb3S-3Q7 z)&i7;u$XY7$s30?2(nJ|_xqCwxYAxYT~Lx0xwHXl9N%(t5dTiw2M%l&0vsVD7&vw7 z$N;3e!LPKu8XRz+N^~A~^67WGYI3~>KBEw@OlBg`nV8n$*9%FK zQ2q#Qwnz7y(}f%T1Ga!}=j2seiIy%l0&PugCrf1a3i-1e`Fx42klq^E6YuL7{|UY# zqcQq9y4wkwA6&ahxKS7iL=(OI4ZpS{V$P(;tQi!FE)I9+xt?Uti^PfDrGO{kkY0WjNc6J)%Jv!Jfmmw zj5e7wE#|QBwD>Xy_uim8Tzj)3n1D_$3XO$2R);cbxBUm5XjC^l-%9-W*y#Jd_z)T> zNA7{lj7K8}ItWDlyWgl@kpU?+U7Rig9VwKBm`S_Od5n)PbK7Lw@npZ}E#&U?bi{lz zLK|LTxXdLr9_|pkT%}Q=6uVE!pUBc;U9m;lQ}UlQ09}g!#(C~pnR7PlfSD<^Df{Br z*5(shHJ!yB;~Gc$ATI4V3-JlDDwXh&9Sdd`%&V|Q*cCwTQ^mq>aCNIf2e((uY>}Q z(*oLOn*(K1fSBEA0h^?NataU{edFIzi|9-dX=H`;D80Eb)7K`7#$595ulp`95d08D zy`5zloD(|Lqta!} zMT7^6xOc-c`O305oA*OUukC29GOM7ZB2wURR%|ghNhuV2F29@=<#hl#W6LYFM){+M zAt~Z|sFgOMvSl6$vz=Ki8)^Pg9Hbp8!Q5n0I?zfu*PkZC;O!M=xbeX(u{z;e2T3ka zBcDJCr=3aJZgWZBY%ckfb}@#_Coz^S=0<+vv+ZbQOZ6U%Nq4i2uZ=+%Y2lE+Vu4I~ z0FU^~VYG^}%^mW_@4F~k^cVj{p z{#0cLzA+0=I4RbvW^_dbgpi&!noY&;1fc!5JthOTlf$YfBhoiz%i!1T=!RLxJKJAi z_w|`$Zx`A+a^oy4*wUgc$15sxCReNuW*&MKk;<##;~;BhBHYQ!HNT5=n@7nfGb7-oxy^HNo9S6{O9Wyz?OXIO;vS*-B z)v3L@M-6g(aguJ9F#+E!Jr8s6Gk+k1shVUvQ+lL_5;GV5mKG~7`wYF8Nysy3x~US( zjZAoVA0%QiB*?QM-r5B`$HLjhbgf;mY?g?;LLG-y>&)$ttMg8vypTvpG_BC_5YP53 zN&$aMc6v8W(zC|*rPF=2(~RLa&K8;Ou?&g$7@@*8%6a0jYLf+yVoXGbuMrH})b<=( zRPy>Y-P=&$0cLMty1oyZ1T{gr%7lt|_4|a*{)-$e!lP}dFlm-#6*NZ%yWc_Kp3MYn z$3fXy=49R!yeG7s4!exefk@F_h zy4}PCZhOdoQev~3=eu=d!JIaPzfZm1!e`RGH&ie@9CjuojMNvvolCI118 zbg^oX&?lJvqu;g#eTF>{(GLk$E1C^+e-8J>L}bI8&q)%kgA{~dWf?9rFSTr@Nu`ZQ zaC?LW&A;~149!7VuQKapcB}G&6w5n-K~Wlt$4^V{U$vnG>IQqeyU zAq5_~wwW*RLZ$i$!pg^7dw$&k|H`+dy(N}IR%E$E&1T?U#b%Hy9%)xLlS|S;qBcd* zd{a)6RE7qTI@mTX6|NmfH$Jgvo*;R$axLel*))Dcp(JHMZEDM8rnjb_6h@R3!G&_> zn9s!bETd@F3q8?Zb-wQsA0AOM70JIkU0+3*zhn9go34O#<(lJW-Vh>KcoDizd4RZ! zncWqJpc8-r6TtywTNe3hfT5cHS4Q1MyQY|rg3jey2!JX8?aD{&Ggagv6()Hq@LQUm*47$^vItmw7AS5N+w%9)zX zFZL+*7{u@tA+B}Ga+vtCTs4a>$_16su56m}xu%P_0xsx49jGSr9NlGy5DyYhNzco2 z%s~*6MLw=T*6w^|S>|G0*_NNAB(9JeRB*CQj><+@#JLNptJJNEo&HU&ikBG@9_|xe zk;|f3pVGDs_)jVmK)Weuq)y6+ZaqqN>lSm2ZQP~29%ZMc*_=e{L|r6AVVC5!=FQ42 z2zAxSaNa;@sw^-pg$#L< zb20zcVoxO8?CvgOhm_Z1ek4hyJXGhg7SA$^W%zZd4jZ;v;A{{JAn3si{1-7klrFMY zb(seMYwABq>fX+<*rb`H3(n_G^{2ZSBO9}#Kx5)#$fW`*@oj5!1#PaNm+QyLT)`DuUQk!2%a>|& z>5WEJdJ`gT%)li1kUF6kg|9f-zw!Y&tC$@B%2Wc**vnV={8InQod8qY<JV+TA#c-?vOS*k2=rl5kcZp)P*tj?CsC*LspVPN$! z%A3h){)HW&%tvT*EEse`TVuhQoH^ZDGAEI+?Jv~krhbXkyeiKV|Gq;1;;)lCUZg=d zxPc~@x0-fNT~G4He2POEb?8%)W^S8Dad&EQ9a8!AQrxt5h#vu&ImzO#vxN-iil1p6 z7M`MrgxY2$3!latn&L7l`p1Hl83_j9=)Rr%oiICqEWx8%n(O6s7XO>9=pqS7zrC}&4dSVG$H7uXZJ8~z9zqaBCmWEyMQ zv;1|xmR!rZ)xo`0@2PXOcDY9P3Bo(#gwtri=}R4xEdO(bnf@(VfvJ#(o-%a7Sh-qY0;AeeltBhx+eec49VgP|l#EG~ z=ZhMGzwT861v+rN92_B&0&Sm$T^7Y7;V**8IM!55{5sLLj)Vd^Kao-pD&Rn`pMrF~ zl%N}p?|fmriR7Ddl=HSXuS7X-dxZ&CqMWyV>bAh-h4xxbo8i*p!#Hsbp+=BKmTX$Q z*%q8j3#5rlvl}8RVUMe6ZFK3`LZrXr$hCoE5@q>Ga=3ss+Yo3pzbX`R`0;T)$YIgP z^ptSsG08$tGO^9(KWBfPXf8=hX(>rZKhu}I^02>q4Psi&C^sx6a)KAOBHMe5^k3H= zkV_K#*LdE{N(O4dB6e|_)wn4@h25&8juy)XWC1_HDQztD%ewxrdttz!EZn=rSac_iU{%%E1`eqtlzrRqU???cqVp*cG*B5hk+*3z(;%>FEe?$w5fJkjxU@i zvErCZnxU;5M(g5uM1+l3lm*$B9W-O8f%~t!^{RVZL~$|WUgfI=tDS%jD?6QF^II}K zY#yDkS**q)!>iU3W(HpYEbOYfpZ78|kdH?sIyzw{i;9KvDIihxge1H};w03ITlu!c zZ6I!)1mph-)yYS;lDleqci=_|+%AE;x&t4Rz#S6U-W|AB0$-QF^g+oomq}o&1P<>G ztdzi=5;&$iaJmHUlEA6mf#W4`j|5hA2c9m0dnGX39XMD5_Ys&}Ofj0qlEx1kQB7?Z zgO{;H~ zaM5+whOb;2w%;?ZTy*8-ORhXD%%-{F%IlXbxbE7r@a5si63tttd5;)=(c&wUDZA5N zv-r9t3&IpKYr(Y@*WD=fYZ=M#5}GoxyIslfvhei_uDyyFjXQsdbi}@2cwKlw<&WKO z7jVLU+$R3}xVL9uog|&;U~L_xXyNyOdfU$l!B;c7 zzI-JCDn@8|Vu*l{n(kJsI+gyJl^7!M;xxgr7hU3k@uA#3l^7zR5ieMn;=Sf4U%#C< zEjPLsDe~%fFs>Ge9k30~l^o)%wFE^7^v$9L0;dDAIP$M07O|ne;8SXW# zupKkKJ!rQCijkZKR*}W*AZYZ~N9287qXaxpK;^m{c;)PisX}A5gnkCbu3V=#Bbz@- z=u!#YO{mw10q$CR2VFvNq4J9MmT@u;w7V;PZI-vvg~M&$CLtSfGlC>G=+UnfwD#>kZ zlmb(=z;@e>YRbE5(ynRRrG)GO)C3j1Qt(2WQ6f}BI^I)RzmZ~NvQbKj`ecq2ZOMO%2RwV ztQ-~aZM>U5>t^?&$Z_KjCaPYSW@phdWf5go?c}@63?SeUF}h2lf%^z&98BnYP&tr) z)A(&_yI?ffz^L{m5bWLyzG!jPf>Xacb~chz{)q;Stn}-zTXa$75(&3)9`2ZU?SgAA z4`1o7R-d*1f$4U~UNWLo0P(kvHxI`P7QbwWH@Au2iy67d*v4P;V-~!_Zdk>Eqj4-v ze_^N;Fr;`AWBLHRdpjxjjP>Bj;Vs#{N{ZzEANJdLr=HWLo==nYM9+|VQkKj!C(RL0 zag+iN0NPCi>D}oan1)n&_KzT!}Ap%S2xxc}EbI!&A!p)@>7gx!WiD zc1RkYH9Yfqo*7=^Lm!cUY_h&zXBPUHY*dsx6aPwlp7<;=iul<)<0*Hlls!`*;PM66 zURg2mhk~2ook<`1ek($HI-D6x^`(>Y+Nlecgj2i<61ymBED!%`<>}>1F9LL~y6*ZP zJ6o$5#Ge0Jdwf64`$nEB60H5fe;=dp@!uY!`%ftGWiuv68l!a54?mIqk|xdfpTt** zFB0vE?Sy6!l9^ND%jX$1vnaA8eBCv+`_e6GU*B&BOE=aOPQ+S0IRHLiarWVTYyZag z9=`MGoAADOPAb&--^cGa=l_|=M4kVs3nu!Ct0wwpFJ(@7*7DrVlfMXwWQfg{)Z|18J>YN%c`!sK3o(D%jh^;rH_3N50qi38Y??= zkFlA5O!wGq;JvfQ_j|nW<9V1YvgrQX+IaA!65oEFBdv|b(@MUzHcCnRKdp_uxh1}( zJR2A@yG}UDD;QU}zf0ZUYJPk9K4smck#-c%z{4QL*(&{E9D0I}boq4_N{>YX3Ci03 zZ~yiZpG|^xfa|}(NET~8lc$vD37%@6U-P^UKA6w%2A&`gUBR=IXARH8JR5j+@a*Af z=SgFHvU!H{OXhoQqB!X%A>l$sG7feG$?e z6qbm4IQru8gWln2-v~WvVDB~u8E1cIM*f|qz2IP?3Gbt#8-#VA8<*;AYcfCkg+z&_ zcPcSvo_q@JmK3`Gnh812A0)Ig6!j>3ENU#aBk!E*c0^2TL|37^ zAG@4ob1(@T#DN-L|6e4`Fzs~YY|rlg9rNy`DLw?TVu;gA27fCGy|0aayRi^INZav$q1x0x%+lI8wD%H1*W+vP&<^{}D6mxk7dAYdS@o6On= z4~h+Kt9XSTaf+M|^Z8sef-UwKK1Ikg1`RpR`D?(>%|){zGSpDbZyuwd9_MpwRLdM2 znSVG1ozCPjCXGT+M#az0I85>noJ`D(`O)R+z7=sCcACFQfI?`CnNCym_}*eBQGyJL zORM(uktxuCcTnVqr>HyK<);BA)*>%K9B(J<{4{z zbV}f`AUGBU4S`C#cK)PpHeX|jG@B7zcwKuiCGwqu~ z9A!l{n^WBt<*ftT#&c0Cn>U9_o6VXBY@JEDARP|c4(lBTa}?fD_J+ka37dFnX>p>g zkb!X)r(alipn8bh!^D@2YooTBi;_N7Z{s77@yMvXz6B6@mg%EiSN^QsDO`Bg{0OSYyQrf$wgP%eMN+{tO!FV6qy&gJIT_2ZC7l+>5+cX7J zAm?>acAuIkD;1~R7C(9MGm`N$6J^2fc*&9JHs<-0gpH(j@yW19ju3YH5yF-oA?&In zgq0m3><32(%R55Yup@+}+AzVz|36PR5AYIMt{x9??z)5U02ijTtg2-aV6WN4^E(L)zC6;@)~{7&h3B(Ez4|b_Ao`W@pHO! z8GYFlBJ0cBTY$_g_Is0^BamtDRK=_YgQ*rHK(o4R0dF7Z+d|%UL6SRVc#4!ISL&2i z6V@dld{-@L__&BYw9-)rhC zn>^Mj8XucH9vw8aRLoygAd-slfG~285jG@C5Q08HM+Jk}fmHy{lvVKL{w{6Col9XAPKrZS z?Wf40P;|rz95;Ib-gRvPr!eSxmmVp8`6+<_i(hR^K4x<4Mk);n;++2jQq|91z+aJ` zFTa$R+NBG8dP|y9ILB;9&|+Qv7kWj`VY~i`1n(-C+Z8@Fxx_E0a6u@zrGV2=FlkZ5 zUK2GE=%OYJ1I0(zjBe)jm-K@`y2XJsE}P9~;BWYCmfmo^HKyf`D_R)7%n}F3tPakG z8x=`sVT)UlQt=&`Chq(H`xLYtZ>K;mBBSRsWeRK&JxAZx8*)BjdS7Xy$dLteh&gpi0CU3?@A@}>GazTMN7eK^Mt&!)2!G`acdHe z3W~zvAN=?Bk96Dbg3ugkKM*J$S9(B?J8s?ZS#2I1^}oaC>%$L&&ngR_)dHW7L2mY} zLDp(_yQ8(hU3k)eZ~C=|m%hkrx@P`=?7a#?RUkoz zB$EUM8A$?Y!4gP9z>wsh%t+LLqXRa{NQ_Mt6pWA$J0qZ$b&*jlA(HC0+^ z^Bvb`mgYN_@nzctbTC@R9*CuB72NnZUn(mcB#(G zIAM5lFO}?+6LNF}Y<^Anj1NPD-3gOqDKZp!oUxXBMj=WIFzV9mnN>N;KeBbgq`rjw z>;1h9l8E0?=%&cA%3ywtqG5QXLS7XSGc6^ev-ch-u}Hl_9l=W_I<9e|Ex6K~pVu#x zNiEW?ZJKrKg1GqP(z$EPS5=nYR&NjrRyPqzt9?2makX!LdE+fk zswSf1QcRk;wH1|33BU*FkUK*i`-zMF=e{KRJ(2gxJpYQ!sd!4E<(pAx9m{1OJ-txN z<=%L9&Ix5sJHWdm8(7k{&tVUp$NNla$B)B%_(iOyrA@j%Qg!CIluhJqLnEXHM%?7o zmqoQhz4aV@zV9y4f&d`kCLtQE-EX1FH!R98?8Ysf66X_)bUtzh&f|D!iS};}W3kUS$bPBa@p5D)W5GwMj@#D#` zTV2So3l+^%iF}Ik_q4D z6ZcaTv(#sk>NiTAeTwG76Ww4M&Cs&CcGj_4AMlS`e1|cx#Uh33K*cr4Rg~`e?KiT{Y zdew|V>L5DNPfS5+4jUX|^V2;JwT-{;rR_Coo`^DtqJT0crrNhyzCK=Veo3ghj3hTH z->Wfl^2uZ@=qZk+HHe>v&h~wz^OycfQ)Q=+FNeSA!buXRY1hyFx3BLdRcsfX&hOCBMShzr*#~T8w`%?4USM0M~jWa-UD|kvEPKy z=QPcUUq~@q8*{}k3i&M+SjsF4{|LN<;iX9{Y=2Xi2-5sqdyjEgrl;Oz??xAvCHZn{ zeL42EFrH-ZIxDb;WG^-@jw|)5Q)A{@1@@Z?4R#ssnwMZ1M^Ba`5h`~|fDJi|eW%t1 z_NwRdCTCgLTLzjw{nXrQRI>)9(4% zUR4P~jZR&sbM)(Jv)#kA`BLtXX>;|rm^QD;tj{l)B@=^9wG7CQnM0A;a4Q+hY^a58 z@9eDs+ID0odk}qZ(e}FM%&K2wrj3I|nFUj_oI*R1Pv}UkhCVtH$!Jvn3oWz|iZ@#M z?pFE(LwN(VF;O@a<4YzGBkDVI1Uqxg_Gd62EFn(e?#z(l{pvI+UL^8L9XX&@=*V^* z2_iirt{p4W0JTvulyaiFjEvT$=nAJUU0T~) z(5&K6K`?kD7@S64i;-6v3kuf#xoSwoEi z%I@wF|JTR%hyE*PaAtP!*}d z?P)R+_Co7oCc)J@azHK9kv|+7*(8zXl3+Q5xU)AT@gH#|-(FuNp%Fr7#`C?` zO;&fyhZ$2D3>Wmgy452u>rr(~fM)6p_v9W6_lhrq;2ouw|1xK|dopMgreA5W7dz9BncKv+*Ui$8$tvi0TJ^U{Rv;2Yqd0eq7> z)^*g_jx~R^8d|CP25~Abrhs3kMZM~L3K;Ta#A~cDFZ0L6UzZ&!%b-T8J5{nPRbP;# zUB8se(;O^}Ggs9=e4fZ|^%H`*_aMbvq&~ey{Ld{?KjXK$FzJtE4dH|9kwVKNNKUNq zo^fvPBK3V)^uPvp9aaw+Y~``o+HGvrC&8v$evw)RE>?AxjNKX9*G*_yMhPylO4^pV zdGbrzmbpq4@@WgkI@OGK-RXLh+o_(SGZ`qCEe?4yy{zG$4A$`Ftl?thCl%ie^`bD> zCKrZY36(LPWdEB*j>~qBGd8cBF=X3g7p7A83e>LHbkuDrv=jrr9K&cb$2PHjGIPus z6_<~WP|xZ}BuV}$^*odoS=+9QBsA1>HddS+6rV*sHOu?<41oIO^r4yUdN3UJCFH#8 zuYm}vm6|Xg)c$i0s%?Ahp+&DARFA*JaECy`G`}nupmc_gD-EtxgMizFSE-Fr@NWq? zT!m54zK$7(K;VlJg0+xJ2(~aHzaMg1x310?{ zXMw+$v%MAe*w?w4Dj|i8RbSVQS4=l^pnGNPG{9aGJt!a@n7X7r^h!6dv8{+xFjX=PQqY@ z#u4o^uM!>C`ykQKv+9}b<4Y1E`|f*@7ugI2T#a7daviX#8cc6Y>SDkK%=Rr;6Ny1} zDnq`-6Ybtx0TlvuHmTYFqzs`EU)7O=Do#f((2*FSvnc^{g|P?WlAEQ$riobFG4G)z zXbjlXXW>YFERZQN>=FPSRBtkfStdlXI=($lj4PP%21Y(NA->b$*jvzdsP#o)j#40y zYC=GWKMNtIYo@bknYUbTnQEY3H{z3K-Ylt)wiV>kSLXDw9-C_`Z?$i2dA;`G7ThDJ zy86lwtf0AK+o_&+%jG89+)$@#=hInI_9xkUld|fb*^w^jRLifCWm_sXD6B>)CP(7C zzRu|BRFykgNFIBS3CWs8GXHw?xV>f3u#t@Sx7Uv{vd?o+tHFy8@6l{rO~g=!Wgl(&7x>S zxA=s_eA4@D4|`+;8_1~|GFzK1X8B9M_ou|k5~u;cs{yruXtSroE`q66`cK}H7k760 zPuO?G3kxOygK8QUX?Yn?m+-Q=Y~PLQFVE=W8jj#3Sni5o=~o|N;}k3h)%(0?EI$-1 zT-Y`%=IPMa@cj4luTS4}18+s)`3KTBoy}W>`hAy1kz#}`$RvpVu78iI4-gM__ReB$ z=sOSr-mQWA)oTEC_D+;Y`rO{cysIMz@kK0=@jB9;NH*O->?tl6MAl~PN7d&t`@g?Y z7)Cv zS!AcZ!+6p(=3~?t?QQ)A%;<2b*Ew9^IXW)1Y`VL%tQdH(G3d<>ArG-DVhx!GTwet#!Y-AYr4el;E# zX&5m>q#I^SFw!vPks?#$NW;9FQ>Vr4n`Y zGRC>M56h^o;d`YSbg4|kRI)~XSSS#z+uJqMJuBjaN9XUJs!s3S2zDiFMX~OQMor^?q za6^2!cxj+%3Fdmc+)FIIP5$81!>~J?1*^3}6@+OlOrVCMx40Ny+|gTn{Mcbf*JCPx zFbZ2rP~k}yWuqQczPL-yJy}Q2B&2wJfzznrkq2qENHr%A(b?M-Pxb8cJBg0#^bvlt ze-bZkAhvlb>--HX zD@SS2xxUJ^R?@=C75>#V6-jw@b=)4RwNl5pt*yn>lk>$19`KIUz;a$F2@K|h<1i=9 z$uF_qx{CBDuH*)dn3SV{7T&`iQ zs%(f$EUsL=s+yxw^Bu{pl-86d)KO1<@na$#Fvst!E37GB73uOC;#1a^OE~v8Ro2e2#jDR{ zFK2(gQ0p%@FGXQGMt^xZ@mqQJ@+`dxopF9ee|a+RTX|mQu}HgA((^pT^DK|(FYo8q z(O(|qeFC_1d6x1_2T!`Gs=nqR=h&8vQTtyp?+?X%ui*VlJUfa1XZI2&E#s_r6MEAt z3-#TN=5oq&&x!9P?4Ue@>k6%wO3sRJE40Sl#l4XYjG=&|lP(ii?rvn+zf1T{;sp86 zSWi719@IBE<^{RIv7TCzvXtl9yTK;U9fekOc1oR+qMuS_IaJQHJNHz5r6U(KJrqKZ zAV>ze1x8qjM&ny%@eT;AJTU;A_K%WLlV4rA@)j8_I2Q`<-yB6Ebx5#M1g5yocT44M zjRKVm)RHd`g&Jv%5h%K(a$#kKU-!?1ce#5&k&3BNOs;`ME75EZgsv5XY$w%?0ic;i zYRYCeU-((#w`|lMt?T8olJd*z<)({NY&saGHq(7k2x}A&QmM*{Tn^@&foP^PWAX?j zTWKZ!6+&P1Qq(AzW&-D<8)D#)$s`q2R+al}d;&28hyZ!*v-1+jR4d8c&8(;aVm1(i zK*ZumvyzJ%>iqRu!QsG^IaVn^@?6K2$e`=b>Lq+1Ea zt80Be6bsx$?WEVUY$USuW?0F(IyxsQ@GO8PGRk6$GsYUVu)Jb*olv;!soXmNrUgXa zn9_`eSlbsy1kE*oJOoI+4I=1Hv62?8Zd}c!)OjFj5hOfYqDTVctfU3C`8BIo-jeB| z2PKv#rYM2&R`P;chrn+HXe$8n!~&gaja^XdtOyS9F@PTiP@Y)e)2y@wwJ{`|b#c;Ng^z0@tmu9wSt0^;H( zk(Vc?PpNq<2@IQR?9aV8_>n0N_A%RD|)6vdjTyKlwOFQ%LCVf8eyUU!I1tS_He zS>;QrFJCCUh^xLlACSrh!x8jL`qWbNxK`eh=lA*QYIS1ybC9Ss-wK_|M5X#x2rBbo z(q}Eu`Af%|E2a?RMvX#rW~LIGwpQm~TBi~5rGHE71QTDSb@iond3EHxmM`;CT1RN& z+HzrZO*UJ$f+=ydS@iW)R`Q7x^o;Ri{KWqAdWU|y`ECN>pN;V+w*Pzc+6{c{yjFZa z{M|w;*>s1r$rdR~QcQr9RR(*8J=oK%oiy`udRQLaaP~SNYqHa!Cz=pL*W?pTh|gM+ zWe}E=qdZQo@|$QTgdR^Pnh;6R2_cKvF{+(FwH-8IVZ6sKVkeq5qnv4TKdrKwlE@Q_ zhQ)cv$dXdKff+u%QvQYMl{$QS$@s1YnLM$XrlBAioen3OgrlRAP?o)VkjN8*h&7sJ zPq$>KmiRaZ}+ku@hT zzra&iR6O_E>*meBeu4Lfg(anBixw}r@g}LONPh>p8_=yj?EloiKk9hg>rApH~&~e0s?94|JZZMp_ejOVDp_-bU!RfU(ha*PdgD#W_5Y#FXN9hYus~ zl0(!_z3To+N5U^0$UwL-sai(&<_A6nc%fIlBR5bw&F51RqsAj`&`Ll0Tu7v6aNkD|MM>Z8ZDGg zCO-e@EK6pdeG-N4c%qsII*}$8@Ox9vzUCRcPq)Le7&KmBCi9DfrgLYA!oUBt$I<;$ zD-uzK;O5tkF2Rx&$uwqG061!R21%v z=1)8tG}I<3^l4Sf(LPsx)m=vyjqr0=YD?xfPyp#tVN+DwA!*TyerZvym@j4*BW-%K zwCT2lrS#JSa(vR0{^aYA#hC!N1mFRbc^BNn86XyTMJ<9;*n%$4->tq&ag))dzI1_Q znYLqSqC3w{c z9ns2yT5^vg@oDc&JA~|Z6uovT$q@XC4~%4yb|=brf0yS&t9Kif;E*xg<>?FOEbHHZ zeawDR3_w6B6NiI2{)1wE_@Jcwy%XBU!QV_z-@0*3oPIG${FWL^7u?w5`LOToHcubv zh&d=R%#^<~7j#s77<-dsf=3I<NPy3?cSS|ls?YRM;W zx*Twt1p1C;r~2M;@JlrO8Vx_=IQVZL2R~WL<@N!OdBo%3A2jfo$#t%H4t^l@Xx8;u zq8@}=L=)*Y$_zBkvV0dYVa_s%CqxrJBZ=KLWS0K3g|l;ZN0Zw1nR#527D*Ban5NFj zb4QanZFa_SWh^C4RVc90B&y2ETOLhi+WE+fx_@GdHjy-KfqP7nnR(YlQ#kpoSta+% zxsFB`23j;=#*hNZ-D45iYo&-LKu3iNGh4RG=&;9-@kwbE)rn6QU4l$?!9)!pXFbvM zlXN`3_cE3Lv*IU5f zfa;dV>^P3jYVxd8610)Kk?ll!Ks`iF7yWR$kv%4%gH-^ z*P<-5Tzu~~RR`5kD*HR{xxBY}UWGHupALdl6IC*Us0sG_Oy0+7u-DU{%=fl> z-V%MFcjV8z^5;F#GMGUzT0MOf{)4lm@Eb&Bt)7+ua`jAkZBmkAN^(%%Uu!FwPVW2dcPZ8Tyr=ZT^Uz&nahu8QoKSw2`fqTFzQ|#^ z*&BQ%W07Q;N|s_8dQd$m(NY7ij`##6{|MtUQ+m?Vp?>-i0~FXF@Y~tD1KQZ9>~)gf zlKDj!BGie#U&=f4o9Wzk?NR<}^Vr#{lB48l9nO6L$A3X+NjWv{Q2p?rRR8--FaWPO_6WWdUOTLm@m(*a)A@fGz-_#tM#-XpG$9xyFm!BV>DFeiJDzA_7 ziWgjtw)HXafdhxRH0rZB_w7_NiSvH2XXTZYV$7={H&TM8ESRy0oNPG2CPyjQ`qd&eB-%QNT!` zm&|-fr9qs7g;Ha(Qs##7dnNRF!1krlA6kYFnzHJpmCop7Xs&@4YlVr+sO8tWXvfSr z|4^spcLm=I2Y)$&+lHON10!&B<4+8}_mAK&t-F3HN9b(fWRLgd57`rTC-^35P92wq z1A*xm`cIYLra10V$xhEle(FI6H=$1lfgNneeshL^r(b2 zBi1Bp2T4qdMc+cXSZ(LVOYh&PsLVk3IP3#{=_^=l*)S6~coNhkhL20`Wu)&*9>0++ z`1JA_*f7IN-}E&S2G*xq{sn8|#C=R>sTnP*?t+c(?7fpU+HsqKHoHS7CsJGIUFf9HPCXv_ zWjFno&FlN6ow<+x6(X?Qf<5IM+UC2kpd0!H#3^_`q2aG?;jf{=wvRZWZ;NI4wAV(4 zkH-~gde`zTLjUoQJ5{dV=@+*T+stT6_Q;I|mI{0{a<|3_N`0DBo3Q$yFVY@#9w_i# za*7i>?&-57_NyjApy@5VhiM@45s#Uhy$1}an(&~;8Eo2TK)T$o$|hAZ-e=Fj2j05ALuX=vzN`&(|f6|nn3UPFDEdX z{kI;_*~>jmN!slmWXCR*>~eQoz2A_9Qha`PSiT}&1lbZd8ebb26nJSNphM;TLKJG7 zri+^tv=r`o^0y zRRYZEwYic=(sihN_e!s=H@ds~#>(P>!(xAAF)SDXJoVr%2 zPmh&WyGO{8hBxJU!q$k@tPO#%4j%FL-oN?w?Lvz*2u-Lt z?r7FiZs^CU?zJb59a1cBzm&^NMm=>S*y5Sn(b4PVGf`I&pRcYdHw+w?&yd)m`3#tR zA|yiRBk=KgGJjh0>}i35J_U*n(=GM@l$vkfe7mN?rfz!X-@<#iSkIT@V|~l`(!}F) zya=r^OSM|~Ue=v4=~F5{q))(A9#M*OLuMsFzX0Ui3NL*=Px z%u=8i))tm#fTEQ5{4F{_uN&)}FKL+-RV5q7%nD(08~KY;c$IS`#Dlz1YSG9)XR{B7f3 zmer|>b%ijy25s)QOno0p6Ye`r7yuKnH&mP@X>FpkSN%rzBZ91*(oD(Q!QaqAM4(Iw zJdN6ZbhzDUBUgV*wrkFcEvuFu9_Q&7dhm4pLKnzYFIjGMYrSC799Os#6e-Us(%!1j zlI2xw+{!ds28IlvkXz}7lVKBb@8pO^e@Yw2l8W9@x zBrPbruS?RA^6 zP8|(nWJ7%>W90Bcnjsj%3w=-4=o9fmt&zwWUTDG*QtZ=3(%h8Wtn$%CCMon8yinnA zs6Vusev0LV&NV>x67(M*X@STywI7AF%#=}UT7ls6(YRQ zX@4>`IVmr6`yDpW6JFhP|8MX@-(WK*$fHe~sz#7+gwAC7BD_$;uY}Zeyzy`ILf7l! z@BJ)JDV9fJ{!Q6!mRFf~L%AW?x+yY(hI2~7!H5{`{~A9Oum|D)5kK^=%~rz?39Pfv z`w#db*_!?5{Lq&mjb621E?U@VhVeuFhUCgh7HB#dKh&h}5XSIBr?8XOsaTc&J$~pg z)Pj4v6zZh>&}$lOVzlf-`Js15L@PCnABw5e{~dm4Kvt$jx9bLpVF+lRko%wWLodpW zCjs5Ahlbg!Y7T? z8@c#>|BO!x?%8U~o3sn8*0P>f&)$${uNtIKtsY3wUNs8ds@2nR$dei;KAJplIo_#0 z!%vlUXXG5_Q3q^8vg7tDdPwt4J91>R1Eu8?=??qpp>?(H+Ord3clRdwTS{Bvd`iE=vah*VeT@lA ziV1q;9t%AnHr84*^p`92fS6k23+qapL2CKnei85?FW%p}tiN^sF_dD^F+(=d#$5sX z(l&|8S>=do$m0R3HTjC_%y)PT1IZ`2tHHvXO;|IPUHHn z4&KQ*-G$h=v(M@LXJ}-IR>f(N5Tb5v&k5J``Ia|Nw<`Vs-V zq*mX1>TnqGTf($=`Z7iPNz3!+cI%psY`b~6)UhhGj@`*2#HVHZ5u-2ot!y*)i)zW@ zEcMZEm>nthN6qV^Qq{v#q9)!zxFVHBQy0r+Ih2Qzxq6!zIebX;kUE* zhLa>5vt+hE2~&D5%7LZV-!cv4 z%t_9`XWl&Bm)COh^w5S1RDmwSDfk)P zEwBMq5YabVLq`in(L=Ct&hV{jxp{^|Ef`B(>Iw4Z2r12EgbVE&%a=mMj8%fZt3Rs% z?++_Lf-XQI1>nTVB$SNBzOJduY~K|I4<5TI@OIgC?8BErw_44{wB_d6felD~qecG- zb3rgLCqv!>W`9B`FGD<6g*vwFM@ygIkob)7$4gkAOV?4RA5`6TZxNLaUj9# zFKBhsH_#k(E^NKKi%4O7oS!Z}1+=lT^CgURA~js*!X5dCVpJMRiQbCX)5Ji7)|>iG zC&cJYRRyqVH`>08cr|m`Oy9MPi{dhiVtDWyNs5%y}o z4&E0;xoc_YL*r$b?#|-Up)f=8D#DZ=^Ym_4g%Q3zL&YeTep@Fgz({i7nH{`~Kk&u^2+5Dc<7RKLsyuL1~l5TfSP!xNxul#x_#=3G}miSEYj}6{Y zAX**bXF&*8W?yCm-RPkyWd1G^i$L{DDb^@@VbPnk!rsseVh`E26tzzB+(&nGszEAj z<~){NsapwYY18ZM`54Hvmgp+4-;%Zui5Fh>)7?rvSx zF(qXDX6PPi>F|RA{(?cT{dyYoXv<`nf#&QPBdky`ImEx_06FUEnTG7{6?6k$W_I+^ z(8h0soT%S!@)L6TMU)YYrCHI76ZIE8aP=w0qn+H8&!5LEKp#d1)I8-spR*q=^= zs%_8764#nv(6>O^**{)X3;vA#A2Jb5^RRaukur33PXAhfq7eKwm@q(-s)8GqTmI2ip|8ovCgLU& zL9woh!=m}uv~FaVT5N)onGkyJb1G5fZoNlldZ?(N^&U~-v&RTat~3tz$;mor(4Wp_ z2#iYTF?HK#Z z@?`O%7VQ z9SOq$hx(p=%i`^!hgi2tuHkLr!;qfGrJKT!>s~W{I&7N1W5osf|}INB!Cs6S?!<3&bU*}0Gm*QjvQ|@CZsRnQ;(VcY47aXBf6Zggcen+ zoL`I6ao*pgKn+4l(BTWtF}ZsPPRX`uEIeXz_xw;E5yFOBsfTg zWPOu8Li9_U4it1Z;^}&EE>`wlBR<$6hbdCHy+AI9f}5}$%Cw$v{nChYN^K1d$w2QRTtEMWU0ur~Y!)#0m-2LnQOpSt{gl?;4VR? zUIKk&JM}v-QVw&yV#;adC_FPC0q)7Va)r*yz9O8 zE@|JFTIcU-o&Rj>{EpW7ds^qe(K>%$>-?8x>pfq!lzm`y2_N6=w0M{2PpC0{VEIoM zmL`4E840v`r{ba^N?Yk0Q~1=^O9E_C)S*3kNfyIPaYF;L9wU-Tb`o=v@+~bFmLkhrr@Fjh~(7lq0?mZ&Pd#i0E6Me_RM@VpAc^Y^B2il@&vdtMe{ zn_m)95SgR8d8+K@kv=MWS(QmVj_A2^Vy3vB-x!&VOzYsMR{FitKAY$7qo72H;U%%m zZ1sLs+Q_r7tsoOgj7&JK@SOhWh{pK*zNXEdXT8Q^)$1aBYM`YRJtZt+v-QbJoQVAmxI(%-%*N5Bk7@f zWf(;i*@!rTL;7|)0v>3YRs-!)%gIP+*%*GIR2U4K_EBglZV$TD$d75h!39%}HqS0% zjq6eg1PFaW6G1-z_Ge6QHc>tX^(i{!Jwm$N*I43LsxPq>G&r1D;NNW{e1d3$aG62) zxL~--U^oY#c%uXB!S3qv7!(@kmnD(vyGVcB&4(^QrUUI4=s3x6+DDQh*=?t6b0t;J zb)n`-2~&>VdG!LFy1+>-z6!e3=lE2+7`>E#ybd{^5U2dt75RUGqo5m&x-qi4Txol3 zXGYq-Ek7rBg#WbQ9mpZLHB_OHA%?l2&=$B?gjVvhg%^0OP)}Qa?!N|WWHb?HCcl$$ zc38Wv)E9`g0H%Y@rEyZJr4gZcOk1|z6QH+SZ?0##&=+GCw3CvHF$LygOb=Ec#0yC1 zRj75R+I%tWSAKSvJICsB=gOk?6SSHmH)ozB+t`~k3{2EBuv_-uQXa+d@}{*d8VVsP9&4n|3{7Llq7z z&=h7Dq*=AW^e0QaTv9W7HQ_jscMHdcxmyHj8gzt+xFrnGJuJ1}3 z?T?(-7`66E;$lmL#3DF)hhXjRRp@=9hE71}`mV8rN=s_KQ|^3niwCK{+=m@_D&s!t z7*hdH7sx#Wn&lB0QrQhHsgrQ`)ISZy{Xp&{%ZF54c=n5A53EJzr_vQ?=dnf(L*C3)LKogxL zYe@mudpQZAEEM7$?lW|$Y@$V*-S~V!vXH^G*>3e0p&feTQNVcXR=2UGfV+~{H7rEQ zJ+dX`W8|y2MHf%>VxP5ud}bTR^a!t>xf~hh2>)d{&n)4^f1xPkS7-AY3YPNMt8V1p z1}VgI$cQUNES>q@VOpl|93gQ2(<6-%_Y>VHcp=GFH%hrW8O}1c^oi7{U{kTBg}aF4 zkryP;FxPH+Z9@W!&wzdJYEWv-)<$|#W?Kbpon~Q0bI!YYQJmbRVGzp&)-atc1T`6g zIyF9h;|PAa*FVC4E3m<)V~*zav8s^Pj^_H}5v?Jd{-pN^AR+g_VkYDJHhv-pB zD!*9yjqeo^x&}Ii1XixOw#El@;Nav8OqVRjGnl^VOMGFCAixGMOzwo)p$pAxEC%Z^k9*B_xOa_L}AhRQ+NiTiTv6RYm> z9I+;@8KW*965>9TpEA*BVgthKxU*rq#YKd^(AV>}Xo8egKY}qFQ{^ttCpb|nJMtJx zf&;1J31cG*zVG{`XI*>Ysz_ z4_XL%)_*d>w97JSg z_H@Xpn2_0_etf@8rNz2gx#cJgKSf!r;*XgPiV2;Z^?aj_-@ZJuX^}^-sUhsHgA=qM;T%rM`detsBd`*?A4S`uerCx z5DFZVp^vfuW6H~pky52$>oe4&0TyX|)!^GP!k5$)KPkT}-rC`oSGRtRlh^a*wJSbH zehPE^1M5fTEE{Zi&}<&f_``Mv*_5N-Ept&T8>+-|kr3!Z|HvN5qTiWL9$H#gzS2D*Om40m*a9N@MxxkjgcK)7HmJJRBv)7kqtRI%@Uu~i^4I*40q<8&JP02PTA;SA(^>R!o3#N7*M4mw(FlHxWv&AG^uFP?*CE!JZB+b>`Sz9ig+@c3C~T#(gYaE82X zALXh#KYv11X#5-UnzPTJ%9R+{aszFooB15`dhkKwU2Z$eD_j4-2=H_;*|!q{QZY^0!oX&^{e|_wRcHL3ZY@hisPkCdSJWg*80znv zK*VFH-UkOUjB8@2z4R58sAFl=bk0{9?2EG02RSq{Hg3%t-3z;(+CP%9sm{(LKegL4K+A`_Jur3hgW3k= z%y)U!7xoJQL9=d<9&TR84pL1!WD^95Urc;xu&gaV0cR&Jh{s!M3FBC}uY#(-caN}q z>B02_*7~c-g79$PW%@I<)j!akpUT{1So0zU20UQ-Mz;F<@n=XKo8w#k2iX`Z|CdP< zUY`n_-0zXh!)wIy}vL=sEma{7&Ds5CsHcmHN5yebW!dd zGRPLIS-J{vdcxKgqdx;w-vlDwc$>P(p_^|sQhym$mzY?+qMplzy)I2|L=HM1wmCz6 z7?$Ccfqn{O;WV^QH1ni&dAJ1#%CCcxQgY;+YO&wS@};(Tv$`-Es6LiyFEn$G(9Ajd z&aBL3IpTyioe|2Pu2yaSREY2BHt!cG%+Kj%+3q-JSN~x~yENpT&iPil zW?IL$Th>DL1DaB=je0-wmsaj64+igKshJARS*AN56ypqw64WS!pK$J*zC>)%b^br}-ZC`R(%4i>NF|B-X$VPlqe=9~-m7>K zR`XC{Vulai_Y+y5O~%bWGKD#e^G^&Fx@hH$^d}c3V3X@DRJ5RPeHq;zMmqE<34NOc zp?Gh}%6;%>XeZ47L~j4S_!q6*CDg)qo`?&D@m-?+d@nZ1%Jw zEKW^{mMnea7Ko#P$#P&^z+4Rs>&R&)YP=Jb$~JQXQK9iuS#LvQLknv*y_UW)kwO8T zvQ3BHy@YNJrOErDyC>86F6RAsy>-OH$}Sf6^}^ zaeMEVcxi$CF)eT>fsq!t=?DCqh9UD-)ac+I{lb zk3@zkSlyXkmHN7Lsgj8iHzd-FYV<+%U(1h%O}(s;F^@uE&&}{Ep8agJGLUWV-&{Pw zHgohOW6GIK)h^I6TY;Yn66Bi#tMhEpYG-dl*!q4S0sjp%NPz3UEer9_C9+?dVyrYp ztF);!1wvkXkfz`3BQVkw^-oAs^q8h7V)q30%*)pkd54S$3bkFAERMSAhU`~(J_(D*b z21)^kX&^FNLuQ@5&u*sy{t$u92Uc>s;ad{<9f^!O;4n@1K3SPsc2GnF^DF6D4eJW!XQ<|j#PgD@2aX@*72jdKM$|`BcBx7vTHS?9ggA8< zE|njoDXs1I${08`v@o|-58{XKxtSrbC zm)V&)32u}GwoGvodD}9@vjHQ4)RnzQ1F~XKi}P_DA!V2K&s_@N4wdrqOFg4onXC2s zf5qnfB`WL3x&t!I^8Xe1WMLKh#@oejLk8EW?y!T|2P~oq()3o~Hnsv+iLX=N#TZvo zAN)uoN~?NqZ&)QWghKoJPIHLxpMOHz?CVQn=MX2#S-Wj{rjf@V)<@+pLkYW7`$NpJ zgh{RWORyS=YvHA2@74{#Zb&5kh#m#)EC?Qnu5^r_q%i%X)uPbl+k#NprB&zx=k1vFo860;XFuHGA79h6g z#129qSC79d7U+&S`s622JAbEd1e<7asfqIQW8b7wVys{rYBpw5WI z-6L^$Ed(%C{fIbp&Rw`6Jc@35pI*K6p4Ln~y>Byf5AO1H^?i69eP-BKA4-g#7l!uU z^#^lApDag)CAk;+7udryl~ENu8n@vJPTt?zaX35$Bby_d&krRAnlnG0j0{>{;x6Xu z;p^9ix`fHG)B+r9_KoHXYHgA0Y`*hJ|25L*^laFq=aufaezExi-PdJexcPwy4dxte zp0!QRG22Sd4m-*N8B(%y1I=fLFC^FQDV@d5r{wETlonqUNcDyPMLs!4*LOzx*WRnb zVhjC$X@|2E8cRIyK_ux(uQ9Ut8~rtSlj=cuD+z3iJo`u`Hlfg~ZQ*+dzXkkm=QoR%5xb(t_!eWL8-d%(@5B7w&+kEg8QW6hecyL# z93E+5=+QsR2nPT0AUv-of1k*kwgK78+b&7}lvF4*UQFbxiHKr$X&r(ySX&}(@)meI zdsA4q#dQlbFLjL^0UZ+X^%swZ9~BX)l%x6w7)(wpEm_%6S5t!r zm$|hoMH9gaV>)3YaoF^Z#FhANtErSo5rJ6&Vn;PLF05STuPJXxY;43|h%dRZ5yuSL zZ1Kp#x`wrl89ywP1d)H)!@ei*T}9?!#kJGv7TKv$J)bF@K&KUrc@jgQ0PeM zLLGuT>G%jKLg}JO(HmM51I@h`wTZ8M5SY^W3i=mCZV){esR=!OGE0OPI1`Q;6(R%?F| zhPLFkvM?D8DzfHY(ad{6P4`26K$H;5rgB~lD z@9b}Qtm!=clyfUj2KgO$#A7AAMP4s>tmZu)s|L6Uf5P6s!p=PdY+T&Ytm(u5d*iH!y#CX1Hp1FyWwht^6u&TG+~l{KDt)8k) zg0}E4AkV2${|XN?o+r{olj$I*_VRn0l@c@j-N_!y2ckCu(FPDinN|vPq0!fXrxl-W z?j4k=r+o;Nb-Lv$s9SkU$!cHa68iLZ5Xs|YCkF~=SjqU?S(Wc^Xsl}(aCxk60w9kA zL~hoZ-~mXgUjxW8qL&ZrvJDUqG;(74f1Zi~vm&ewe0tHl}&b zwiyAz@LlSY+vTyA^9Tlc&LJL`g9X{YnWOzX3_!9IV$x5v5(?pAB>8gC*Tj@j3UKal zKM?|W>`lrL0|=aTo|R$yYrz@9D*QUtRtV@#;M_xYPSeQm`9s(Wf%-lLuc6SfP?I81 zQhb5B5nNM;;kv*|HrYCr_y$0}VL%r;mB7a0I&l;=&uiRY?P4u+@}yvai>y)FLxs56 zkQ}j#8TNuKlSks^nXG+4X*83W)LSWbW_J_~<0E`AtVH>W1w!-%%XVs)6$2uuF0qmT zDe=|S3&djbnMhfhW4eAygxQ#!;jub^kSDgZQ>_#{-;~!btZZc7i{Fij;&v z?Zs+Ejdpc)FwJAN10YW<&=nep30Kg7>zmQA8UV->3v{IewBXjt29*krK@H@I1)63% z%~~axmIKrefIP84*$$9k+CrIJWF=25(C6@{cfEFci_#6smnpyt=zS}C{=03lB-RIXG_<0`A4JO*ZsGRYGQ zGs{Y~VHQ_cR@Srw<_1KbSg>oXj94%!n}8MrCQmHrY#CNMSBs`+u^@A#o_J+x@JSaI(}fv8$P){d7lon|-)HRg10hc=RK8?aRx5}?9T`vI zYcXwZ0TXT&3uJL!-7W3c%(3FWdshD0A5QsT{-aqhd;W3xV+Re>H40tZP)C8Jam`&& zQz@+A)G=-=?u9>$_|@AB_l^1X_pFIOnRWNu2AqX046oq>9)G6-9OW2=Rj4PzRb}rg zlB*i$7tGDC#yjaK{VMP&RgKj8wgt5~jEeAmdjwyK%^%KPX}h!%gdN1Bu2@}iTO&?v zgybc!SnX_8P{+8ZVO$-4Q}8v$38F1i36CFzvnR6^)NP2s%bHAh za($iMW)-94ReKK1h`f4s%wzlad}Oud;(uuSGd||&}^v? zJgKGmHFb@Z#xG^0V9N#3O6~ZIpW@XOmHZUa9?2`qosKeC7&kiscBL3R#u4p^;f`qI zY{!>Fa?@^DB`0w73yutf;|70a!)+%*etzSs z#L~s{udBQ*E~&U2uBbBVSC>xEj&AEEZE~p$H=Qmn9*>oEYu5svu$WDhl~7RbD|Z~o z#!-rz8Uc1n;rvQLtN?#RARr&qZQReJ`yJPF_&RgqN>v-(;4?54lt*L8Pv zpItLpc-%gFIe4ZXF4X(%9^Oy1&u)$@()(=p=pyUkF-6wWjH1XsyJu`sWS{-==|z!! z_JPZaBKz!)bBe5E)T@cQbX-Z=j|#0lmlj#u#}!#kmxGVIvG~hBnJ*$@%%!DLnf6|O z-TYSYJBz)_IO`(oYU?g*8{3I7ai_&ij5{YT5t+~!YiwMmb>4`{)|e3`)+FRnI5lja z-EOs?)}GrQ*FLg6tv#cCbo==B)7#H#Kev5s`^D|E+Fk7h?T?3l8vZDJF#K4!J^YjK zkMR@xqwvn~ufzMohr{oOe-(Z?{KN1|;mKzfS*{61)((E%{CdwSvNrOJJG%%ol7#bg z@C@=iOl=2wtck$zWSmPpk9A&=HI-+8r*u-0RWOZre#d3=e6Gmac>(djD_VOW?*lvs zM-^Ft6# zBRb}#H#1)t`kl(R%z?ekLy-ae|8rpI92lvWffU=tcz4<;iL6d_w)&d$5CPZ4KxM~3F?@#!1Tqj&)WFtFh}mHR zgsW&2ZZ>lko8v4VCr5w+r$^i>%VJWz$YX6}9`3ZOFA!%~sqAqOv>X5C0+s++ z=`gS}kw0iKo!yD{^AlqB^NOnNi|IEh^jTI0V(Qw)dhPC93+4sYK|r4!270zNemJP^ z=o1M@&N)s%GF+e_ojuVOD9GshU$p9$VLMwS24%7hS$PYt*~{_!F6`A66i*(fVPzRP z&l)|HArp){z&KnabAD7Lb0TTWq<=1Lx!|8mTP}=9Tcjw%#SPN>7sZMjP9##9Y(y%; zuXE!hoF!8{I?b(%tx-a;BL^1q*x>9cL81~fq()kaW-!@nZJ70T$hPDX%O#9Y;p&>o zSiyBnKF0~JOApMk+@Kj4$r2SUPhg6bAd^X|d@0fL#GtXJTFLNi-iFFsS68lEKA(d! z0Gg79)CnO&f+I7@CR(0Y(svn~yPAsphRSkZr51~9EoSKhXzDOLB3xLprgEiEu!(O? zDb;csXt-P|%Ms}~?tx|2&0{fM&SU=z@Ef?oO7pI6s;p`BR?4wrb*$(orka5(V?;l) zWyzv+_Y1CQOIg#RCtbqhe-03N91y870*2_0KnmXuj%Q==2+-#^?vfpYmXQ4s4D!UZ zmvxnuZ1z1RwdGns^jU(atD}M_sr>ukkjKH3Oh(he1BN_*RaIp}?7@XoWND${2NzOm z5lB4&{c;3Sz~SZHIsMXv5QzJSjoJijq^50h{xyZ7?1UkT$q7&LDKW=oG6uMa74{Ar z136Z*fs!#GQh*kK!JKpjooR|4ac{EYvj-0oe{Zbqg8E6ALlh zK(IkO2*g%m<%xyhWR#p_3#YeDCz7EDRz8fhm{WFin3Vxn7aZk44~Qa=l^) zXt-Q2Hp96Z2no$_xn3;LwGPn9_ubTAgGBmy;DIv5L8`Y%Wa%li~f~v3+-wG`l0f5IlPUkS7+;=cR+?K;cAE$fZ&F zA_MM3^2KGb^2J@h8oD1Fd?ot5llS*|2LFToS@R5buqTmGWK3tL`5C$Z|6h|)jN%M; zn>DpPuYE>)O8bl9=fgh_4^a0BGmESzcv5qUtOGoQJWbSjDRFyw((RqJaIM0dNxLTv z50uW4o!)4Brx&NCOP|Gaqz&UawrqJd+K;l74*w_dsMc7!Sb9&Uf7I+o`dwmu!#0vOR(IrBZjmhyl4&D6>U4gSq?zA@AkV%?P{QD9#e% zM~^C%qc}O$aFaL|(Uy*wdi3+2`|Dx#;@eG%e^##o@4r{CCD%LkN{p$O=E3={zdg@_ zS=aUT+P|gt@4ft{md>fKuUWmaT!g(_q|8Y}f}~bM8)91%>a*w>KWhJ?^ND^mxA|tR zIk-qIMC}tb)6_$IM);?u(SF>>R=H;5JMPJhV=Uy%$`fklO7wUJI z!9g+Hg<)EiO~kaK&o-P+4p8j@G_TkRx@SuT~(q!Pcc9;wM5M| zZ|CW|5$d!u(V}eusx_l^Ny4M@#vMbIg34iVZ&-U}WsH{DzNod2ZhUYHTCq!PQkD%o zDgo0vbaGLCeD5_!`BA=hM!vYK-%pdOji@hr)pKa7Z_|0pT_L0M$*rI}8th7UHs5lGSXzMV2go!LaQiCjtwAZ@kB*cYw z>+Zzvi}HcKHDOX0ise>lkGJ}ufOMG#D!Av9=Tk#6la-Kg596_tE;>&dT@=cY^=km0q>L;>vi?F+ZebWbfuSaaa;_%cEl)5$GsV&FrCyS3e$i1uULg?+LZebn7`zL z1XKm{m)P$WNwNCNE!rMNf|&9Uf8&w+`q~T$7d|N2cR_Do=EEi~N)mEk*nfq-D>T^U zIfkk2L2e9eE*sc(z{8O7JV06JizT!AD_F2DImAqEr96?Dyi=EVKuupKMZHRj+Hck_#4*iw{P^_17DYF&_={^Sc!$&Pv2Yk%j8 zbkYAN?)~GVEUw4jO|pRifsGgt5F}!(U_eo@A^{r-2~j~8Lii;jR!n0`6>(Ri0xoWX z**wJZ5v@O}6{@zjTBT}h1O;?4QA;gSs}!tKOWTQyHCBodBYWTH%=2s(>*s#&eceB9 zEt_X%&ip=e=FFLM&g8V>(X?$^fkd@UEAi`}NwP(^O&cltx2@AgXS7b6n&GrTp#$av zsz|dzX@ic4^>tIpaM$-j$|vIvR9MaSS{<;{ouf^2heAW1gO)gRd8X4e>6bjKJhmsc z!_KrEo~X`oT`gYNU|lVW9ZKZZLGqv&et+2qv9~=L(qwit9mRG~{VK-IC+uN~-cF?y z`!~Kl`b5^bzR>KZ(#u9?Ebl!!Gt}egYoSSr(#WlsWrg~07`vz3H=^{)rUB#mn7At} z&TPbqVK6tVvLvgrLW5oAetA1l92s`eI3Ox3GJ=QjK8Uua-OQDi*t#x}x-ysh-C8oJ zL2mia4sacisum&DN%($=DGTp5OC28tmOHA!A)|}g!=Z|d3llVaW9sGi$dC9w8 zR5K7IF>EzjMOo#197h=$#_Kh7w(+Qt72oF$nTEb zBe7!oHy`h_uVXu#RV5_`o-Y}awTln)gpNJv#`nW~TT^NAi?C;_ybH$cWrVZ&EZ}n} zzE^9pgZG=YiKCFw1?+GQ9pN;eo-&qOBwuy3lYD#@_{gDSB;A;;`9?^-J-ot@?uYUS z%TL@&M(V!wg%|6`5sZ!a2x7VMi1Y!B860@NEx2(%CI}AV1y*=jPSLzWpYKbY;pPa- zV{4M*dYdCO;2U$OCmgj2x4wvuG*;o3qf6R~#hc$e@sV`!X7;IHFe5(NihYqzM;9ZH z8EaMb<^gPL=6tC}+M(ID-+DBeg=gl3r04spTQYdh^B9N)E`;@MG;VjKj#145X|XMq zeQ%F7NLIVC;?lgpgODlLXVQVnIc;SJhJqq(WhRe5I$mI(wkX>gxiHkrIs@Bo)JJXc zFe2C~9opMYhc-Sq#SR>MSC$jzxoCI3nYZYU4oDFU55qujB6Y*T%%8AkK@IFO{nb(9 z4@8@fiO5`@Lv-fyQxd#8+7)PT`Ej9Br2*fTpK0xDHPu!j2xh(_qW#8HY!)L# z>^~)TaVoaR#=a%77o}odSefkh@fyo)m-wTdJp*?X5>6I2^!-b@Zw&t~gZ+Eq!%ez8K7`I=;%B!U18v!WlziVhN_+fo-$o#SHVVM1aEJ z;xJ!GrZO$#N0jeod|Kd&(lUzQ_rwq(YF*|o`Nr!Rqn|I~+X=hOv+xPfx#G&g(6^m` z!x|3~>%c+0{je6^GmXmZid7c2ma>OJ`8Go&0fpwpN(=S;QXCu^IzAR0*;+Chk8(h< z+U^EQ&L|UuqeI6v21m2Q_l6!I6MGY!5kD?-g*)-%hAK0Z6RXT^|2ge)O7n|%t@2|! z*`r}MuN>^wz0;4cAb<7N43cwslYIuz8lPA6ii595Y1D82dQ>dpUMqTo5a#ZW5w@l0 zg@&0=u(M^s=SN$D;ITO2kI0AE=jH~UKRQ=R*z$KF4>g#K30*BN%?%BfLqu*+QyYr0nA0gis(B zoZ!Vzb>p2kVikD}udmFOcmDEZq)(TWbxwu9b+zuMttBUA=v(pltME5PBo5A|F*sC! zzk)xqJQt(StK+R*_`dniiQ6$e#n@ zGT5e!G!t`pW-Gk|Pj*AUgGFM{M1U6e%S!X*9iGM+?(Wyjj=(u87R+a7!S4_IoWB}M zBj4;&g-tV#h)1O!=2da#Gtjvuuc*`M5v$8@NUrSZ=4>l_-|kQ!o&c^19sh@nR=#gl zZyBq+SlLGjSv+MQrAoVr(n?}w|C03FSQ!p54p(75S~Atl6n@6(0T%dbaV7dbkFmt* zoJ>Y<>C46t9Jn$9J!A*%VIGAlD2eJ}PNvjm|8`}T*=U&X9@VjVG(vW^P=88F@zKt} z>e!SVmnyI}J$`(_mFzm69r&vcv!=>}eX?J~MkrR!5x{v9reE3QbI`Vrt;qq`#8R%%Tm?z}ZwFIMP4TB0N1$T|`>AVCO>~ zicw#J-TXvZ7sH|NlC&%omj`;rx*OAxl*1G=ZTV3WI)z5xCu2xER^U+wK3MGYaqHLp z8rSEMm7n9%h-flE;N#{Q^>m9r*{7HuJ-MGN7TSLlTECa~Rj}RG?>FU}{iwrCx?cP` zbQaC6D4Hvt2!OwT7JX};^dd@>@M5BC-N&U&gWO27EOpw1&EHShyzFcsORVm`c+wUPLj z^}C4kp5qQr8H%G*c3ci7DL+c;BY3}hB^JQn-TV zI_L7fQGZ*p@SpFPxA4Z0D5cl}@YK03r})*C=Md^osOVn=Fv^Gt$@n#oGOs=rOoW7 zZxj@2mup@*3LZL@{^&;;%X@}; zT@>n#Pr~hq9=r#axhYfVj`)T8AFLr*Tdv{%s}v%oHcF}S_F-3muAih3I78OpS6a{5 zC9wkH&9-!G_hVC<0w(+Wiv-(=vCC05Y~IW9)}rp;JnhhBj!=krG{(QzEqF^AUul)x~SoE>!u#m%;*;N5xwac1S2VZ8Gj z#4jhFUE*f3B<*sxD27hUGd_6)m`4m1IGFqSUOY~GzQ=q#??`fvbF?{B=og&+3dt;8>z6r^9qq5Msm zGIuJ1GRY0h2MaG z8{ej2c!kX`NX4z@$%&7$QBgg*f>szY|(pTG-bO>+PRz!kdWMjrN4}&ymr7y3{T)PraUPUhzh8!kLH?=|sekrP?lJ@Q&)Yb0 z+#6{4r42+H56SpRNh?w%;V^{^lKtA6BQp6HHQ&=g>!fU-d4?jJ8zc-b(pq-NFVB7; z&b>!Eu<=1g(%f(x&2N@4tjqK>5$aaqcGWz`hMvNhDAiG5WP>!|XuSOj5_S1STE-J2 zhb*c?SnxK1RIV-LN*jVf@%GasAHFnPMBE2JbAwcEda-@Q+j~m-$5NBHd@WJa_eM(pX@G(;* z&Pjx`It2T=@$r9wz@xhi#Om&d zJzGL$wP$rp?AR~_*-C29PLGQUn8c5F^fNXuzYWJchs#qg$Ige}k@6-8p!k}3dH&Jl zh9_xWV{{~Otx@!AeVMIM^tmL25~nY#H9A#7dPC!sl*FP73ARSjg=5jdAJ2p%jkYK} zs>eR2Hx@m}hxT%DANS*XY>pb!%D#vABW`}r9^w4aUi>^X6M0+|g*FxRru@j?$WW(E z6#hT)?kM7UpR8#_=5j}oh70)=d)M!|p5~>iqipqx` z-mRl>9RC8d^*d~Y$6~-9;5~ZTY5v3YpIwq*6RRjEoSR;~tf3D-@z$vz+}99UN~1L_ zt3QmSe*QXplsI~r{v-g1gzTtn3o48gk@+$o2U$@rG2R4-5A%WeUT*Xy=8Tn9l zSksA5!PH`Cr#Wd&WVL(&_9qU?Qdp&%Sugseetaz+&$X;APwMWbXkX|;>D1(oRHrWI zF_bPR`ZkHl^}G1>s!9xR|A?Y!LG{*OCC$WHx@lyacIq<|gqksA5m`5xq25*iHl>%! zk=RMUUiV(D`vR%^h5xGiJ*|6Bdfg|qUn_Mpa(ca;5oT0&P%)dG?$g4nAo?_W9FR^) zKf;_5@?37rZUj7(+rs;IATwK4FF4Y;SvJBxRYu+_9=qyx`g_|I6cXn?rDy1-c475d zO9O_Uz)txmW`+D?qT6I%INf>YHs7VJk~<_4>aTyz7grrgwl@Q%@98y&STDM*LbKgc zyviRAOQ}1jQ|fKD)FotXGrI>Mi<|E}EoJeF#n4pU^DUJ4=zZ1PUCk5Ws`FY(Di#1|#cSI2p(QQE@^tCQ&8kcRd2C&c|0Po>BXElFxF?g-T5i{6JnF?rWf`V2{z@F9?-?z4RlDOwiooflKh~AV(Es zt_LE)RKs}8r?)cK=EU!6H=Kyn*d1MAqnifQGs}(ZWc=}$R;ZrCR2)K4=3BmUXA*@tI1UKtS@-ltLR1Li>dchJ^9IzSMV& z);M8_mpjMV*u7ibd>hxFxC_5`?RCqq78e9!?THtdn^XK{tNGzW!Y+k+=@z&5d&=Zl zIj?l5)r@-_*N#y^9qJdp*X8+(C|D8mf$i#Mu{%%PJbS#GwyHZ#soBIlpKtSP^vO)< zE&dm68<|{jtE4hurCnACWe;hOh_gTYx$AWyW9B!2(&DrEEMH8F;gA?NpF`t<=F}Cs zT;N-?eB$5F~kSDA78;UBQ~%r&DhKfOdOmlkz-VjOUEb@;s7Hj7mvi9#*&vQJl_` zJTWh&!v?-V{#{P=Zi316>-ZJfA?eR(dY(;vPE$8&s>~(nZ=|R1)b!U<=^h^3^n2<3 zZz9^=s|0Q3zd5E4<57E%cF$3OLI8r%EfrEE_o|2YAb+pzAo*NP&X(jkX3PrA-T!mM-Jv`Po#d20qci*`*^%{GXuThg zZrLFD5pL+j&V%yC&BfC=v2>(Ab18Q{yhC*;HXR3-`GtjukZS__20#VxHMlC5kBndc@q?}^1@?_7u z)Ma)7#H)xGhj&JIwcF^@UK&99blw7wM=|9RaMFK(_19R-I4-wv0~&It{U ztryC_A%dwz@2HT`M*USZe|Vw5`h>YngBL=)VbeFkKWpK01YY$B53do{DkF3P;_+UQ zJ0*~rI3@Bk`S^;tB|3NFqPZ-gR+EX}N`x-0X3Uk{^G?gz$!B8xYj^TUi@c!2^FWb0 zG)PXCM^0L}`8M~XeB;aziL~nKOu=ig`OA#7W8FN8Xoj?}g{a5dn@CD@z=W+st}Sye zbg*d_8E9zXgYC>7te+qt`X#Xc zGK87oVY1Ub##}+dPM7cd`8I2X{&pk=6X8S(03`t%-W6yN zOrb4Jk+FPKjLy8_ctVjDIScYy3NIr>D+clSjSDb31B#g$XxQrI5`u2YXrSR25~&$7 z+8?stxVpwua&$sQpuw?OqAiwu)!(Y&gHBM+BThtOahyH)9#*VA4Rsk2pqqNlzLm|z z6;;jrDs?EK>=L|YzjKq^j=zTQM_g!GR4{Wgw~^>x*L|LN3%E)mmRFOKC=(1 z&+J2R+4a9jJ3|#ymYmuSnJ@eT-U(M}E3Bfzc>B*Gb!jfMj~*4)=8&0Gs`xL79nK9o z(evs0I?H*bx*n16oMZZZ^4(s)@!6$3(p7D;Cycr!b@g)_HCS1YH!MrONDa%pR3bMh zLG#LusWB<;P7$?;L*{h4^R)q4pZR67xjZk}dM(>ymE*9Mt7xp9f?t#YHhdl0bS?bNVwcRpX9xez3>O~$KHQAwa^jU+a zX>-(+1sWbDy2?yu*OLb|qjk9;-@S@Y$Z&IIH*9azAPa68AEpNiw0POQTb7{Q+ccNm zO^39%W{z~Fo1C4`ceF*i>A+1~UOqS5;GsPY1hx6nM(l`tUA|Y@V^Ux$04A#F#mtNZHz08KHHtvd5hn zkAMDWr|MB;?OLUIuM_|)5dQ&4l)~{kYSHqK|5{@{pfU0G>!HYr530=ls=Wi+vBAk5 z01q7TLI-b<{1rN&Z`Cmb(`xe_R^%#w(H~|ym*hADi{6+ycUEl%`spa|dXL?mJllKR z?mem?Tb?}M<;9iIEl>VWUGnTw+^Ymni^5<%j)i3ysQ(WE~$iOc>|lOM>> zHl)39U2g+$cpW|V7h;q^;8lfQ4<#gU-%G**%8RgL?2E8*GhdbI=-*Z!WvI&B47!O41OiTkH#+1%O&Ug!`-T zNBpl_9A1{_BR<;QfW;b6dueKh{CE;b6)*QcQ<)OE?Oazmvk_i$4=;F5RLN*)AfHx9 zDsMR}&$1M}T>yW_{qV#e$?nJA{z~JT?tL(Yt*vG$ld10t3i~yVjQX~{o$uyJg>p&5 zblf`Dd3J-~@=k_wMvy@k-Rsctyrv!~))W;}e)gl(MNWz-a+AknPSVHn(zBV*Q_&Ra z*A$J=xJEtaB#yV|okoqb@?K9d!BC-01N`T>?H)><65V1K`Vcua)JW$%d>RCTm@~g+ zd0bvzNqX$gxgK#iLpK+5X)&3U=^iG;?j0L@DzP4qnK2DQ_YX%jsf9m2dQD)!1c z+vdtjm8FE!E$hz{yUWTJ>~jgHmM6TUb9p{n+{G~m`^<8xwH+I&9h10|h%2u1hx>!% z1Oo&qqP>A>rH?4*+BlnSuo8bn)$`Cko;s5S(UaBz_YrUs%V8JhKt6*lZ~O6dBeSrv z%WDONy>gz{hEr2*cz`%*L%_DdAxIk%ehPk{b?d%KYvs!5eW^rQh<;AIsbrDWVOQe7 zOA|sB0`@+^%;otE`1RDW*vcr-?V0!!;d4VjkVnw^N45(8h}4k<*J{242~Q#ZztFCQC>R4prk>hpAu!dE)yn;17XjtLhH_1CMV9oJ@L77 zYNYi}gWb)}!NQ1xQ(pkze@OrjUHe6vY-4ZiJ`tbt6k319qH^BtfIW(vbHbuZBIAQ< z^{Y^US=0S<^-5? zj^9^u{O;;Dl6m)BrhJohIedXvyJ2AUBB=>Yx9UB*-{cYYvvBsIv z;T`3k-NAzHU-CtAT5?8L_%SEyjUaj>C#-{jm2%GBk(hV-LrkRglBKg{accvcFpoqPm(%02D@S=H z`z7%YfOn6~r)LqB1ALY#`hJB6xKCpD0+>}gHOQpp+7|4P=s3{}igv|_^}wH$_$Shv z@qomv6iAvewJFA|_ zhD{K`@+7)?frjt$8QqbuQc*ou$W5tSRX*`H>qI`9P}hmxhIsVE=r)mna53sGrm?Z| zp{icfwXLmOu~gmw5A|2*+|`$GO#Xwf{nzAax(pH`)f0`a1DF}Rr zu%?av!pJtI_~8HyyBrutXYr7=zmO+ViHLS)2k!VSxv=o~q~A2m{-^m)<=+|nt4#aW z>hrwD_SAMz)36|}785sXaJw(DOh0zGO+z5&ADtP#tgRdy1!>(N`IESqH@W17DZ<3AE`$=8mVva%B0Ji)SXJt ze~O{1*Xz(^?=I*hNa1KS0@Ch+u6a%f_R}@&ssrJCQ+Gr&HU3`Wg?$J#?56mps7yQ( z$i7Ek3)G7#Nc$FkL8#hPTYO2pDqdxvlcK^0N zOBjZG2{+cFgI5sTd^a99$GzU-qb}2<7TKB}(JN~nM2u>(Uy$3qI?`&Db`f)}NWfhy{ zQ;usqoP_63%PYD(PoTkL!vYN($?9!iZ1cU`Lsj^+=6j@sjq`Y>$ZQwQJ1x;;2&*^4 z5N3QEX~>l6^4?))tZcuI1&{SPQ!q0y&J>i$4?0uwQ3P|Q41&#crXYmrbfy%*o;H`g z$LQ4*(08wPPfoN?M@7V+5$6!;d5JO3znfnQ(wY}ep|zhqw)(Mo1d_?mlg;-?G(+#{g`%mXEwjXl<6p5bR!KfZrUg%WI|2@Mf*PQ$f zExUl0=`+>)8$_66=hvP!d4^NAppN(KY?a{rs*^I3~&@B5d6JDN+HDy|&MFv{^ zBZZk{VT2EpTaPc+rr*Qp0ocy!NPM!|SuIv=#L%*aWT>q8gHQp)(M#@T! z@R>A4u62HMo(%7^;}|93bdi=cbI#$+t|~I{nnRp>3kBO-%^K`9p~1bJ^0BcyH11x( z1yYu}DV&ztOiyM_PU>0?w)Q^}rW>G75c;8Mz*>dZziS6rp?oWAK;FRB7jVbzOJ<9c z16OS&Jg9hOm#PiM?vR=iIZU8_=@u%A9>FF08LO+YQ6)j1d%n6fr47Or633nKQ#hTq zSuIGD9Iaxj)7^|q-Hg-8IJ!IIbj|qX1zZ&NRtPZyT8en-aLMd~K*Q^xIstAPW>@#g z9(w|kr>ZVYW@d|2E1#g1YPn_Can6~|Nsl=XoiVqf9wd#rwQ>qUpiBKb!bA_ObX7=l}tVwWjcA zF@>d=W~!*(JY%!eYny<>&6O{8dCt@YFUfzwGguacNT?h|D`WOfF~%zVDP`jp^o z3Clx}?QLVh^}p))nxC@`qYD(bnC~l~Y8P)+6PV+DU)Mx1?05F6|Ae^t>92$?3}Vf* zzV0F5beLPN5Rrp>VLVFOi|!{)O05IVa*cK+tZ{pgCyj6V-R2@`eh*+-Z0AO|3ZnbM zC+X2=P;Ex7nu9RFv!OJ46viw`R4!Z10vV`Qb1CbMYV2LCxAccbl^$@9I)?%DOM_H1 z&OB5lhdkL^5!BGgzwn+W!`Y9|-Fzarde)XV$7=WG1R8!M_4L(a)Xj2?T9XPp7fy}7 zAO|^LC}bguFPIv-#+3siM$ueAMPASvLzj#@tS8<=_sT4EqSGk(BR69_)ytC~_Hb16 z(Y?tCh?@MoV@_^B5YUrmj^|^MCo}p2V=sf?=G#os`_2u5VaLJbS{E1nMk$8I7*pUMRrn1qJbEMgs$t00D|t~8R|^ymX;T=6dS@m=mXhlqp?3 zz3^rgSuN6g|AvSPcHtJ>P1}t{R+y$Clp1Vo>fH2H&*U{vA%j#cqL-10Tv;GnpG=xd zN2YBPi^!TP5=z?oPaLzf*N3X8fT;L;V;A% z4IPXn?eJ@yW}+(!dGYf2Ceq|^Q@!;q?!QlCZS4`Lvq7ksW^EJ3tApSfYEfj4%j)(-fgDz6bIuXHJSrXQY=z(E&NasWurqzsWmV1JDThG&Ii^OO~ zV(k7c`W@)La43WclCo6(uJ@#o7CEFr5I&Hc8g)1_lBkS8y%KR3N|ruRF8~Fzrjcfm zHpG9K&U0F6S>elJF~_nERhpw{8P~|kq_$_J`7{;Ct~3V-2v~=Jy=wyn8hFD7Nne?rwihv{sq@+~ z2eH?FCavkmthmZ(p;KK%3=LI2`{xQU1^`$+6)2mXH_NU;6(8KERe1fyl8Q}8Mu*j1 z?acAJ@SAQ>CZ?C>nHIB6)J>q_bq;c~{LahfabVK$&y!pahU~v}E8>Y&xxVlKDL|(I ztW5v5^CX^?=88smRn2s+G2s%@8(1T#!A@94KJERw8?s7UR4&H`{f2Q(zW=&t{h^M1I{}TAET+d0{#e`Di z@d4@=R{J9O?|6F!pXBY~1H7F&*P?plmW961w@`p#Gln&x+?w#d+8}c9%Qr+l=3s6j+{s$x$dT9KgAe4<)!QG6D!U z6mjNofs_K4GDAHl7qHI5CupAIG>lKrkr$4N*00?1>rsOZUl^MkzBseSg}QuPvq45RZbl@%e9mU*km*6 zxhE~Jj*-avxpYy4j%-zu8J-MzK8MW3r8(;FOK)X1iMjB;(8=DGzpVVuA^)=(iF_OD z3-^g`ovpF**f+L8F1_VSA+p8I*P4l~tYnR4B#y)5o7A{oGMQ2i5$U>t_;ApxH#t?R zd3_mgfmj+KjCG*lIC2U3F3E}3`7^?o<7UB}-Bb92M3!^eSUL*wn5nRHteJl`?6aGk z7{)cv=xnaSf10_1#O4|AjoXdOqc2Z7l5DPeuX)A+5`Hoc+vlb*AX-b}){a;i|}1xo_}=ri-#Jm)qr`=8Fb7^YR<^-Iy60 z?99vKBP%xF-+WPlGcVVR&GBNV6a<^66b73w8rnQ%keqH*K~2iCD?vnNmY%z0BrEIX zqSpJzy@I0`QO4>jzWo68uk;sv8XK3USH=80$|+ZMMK}cp_fYi1$n*5zdVFn#*$>l5b?f=WF`oZhDQT?{6+gyRO5` z@zR}&3e9rJly*l=SEx=iR-#zRRP&#D+5JSKWqB>3_2N&_S|+v))irDdY6TuGO@l#E z^br>(Wx(jsTf86k#QF)}hAUQ7Ln!e{)hpB|y8VFotXe)k@jbj9{v&7sF5{G$XZF}o z;Gvi80SH9?7}|q$URI@4uLnp-dr54BTW+A?*D#X=A}xBM7^r^`;g~d`;JJ-jAMBdrE8 zeB~=gA|GW2qHmJH_F&o6RIhttry=Cj@1D6I7_4V*aa!dp!^uKuq_e1kKzB#87L_>V z(~oIyR{2z~leGi?mrj;R!vD8UK4W`q-aw11{V@WQvI7kdxx?V9$#>7ui=+SdIXWO| zUSrbdXdkwB-#ACVl>{%x|JylgRbB35P)p2xbP|L)$_#&74p?2rhaq3E<`kklRPzM& zXJffon5~@N|n<-%#Z=t+I+LRhd-Q=7H0XS({HM z%~K~Fvo=eIq^-?&P|z~>vs!hnI3-IF6NY=k)zC24Pk|?8>ML<)Tz53t{(v1sSKt*I zUUM%IX(ut@p2GMfXx7sD#C6CohV|2oS%83K{bDL2bsIXA-sMpn)Dh34sjtFKdDBm9D>sU^yw=`X&Gh5U+bqW7-5 z!awMZE71ZH%oE5|Uq2>QM(O9rOJDy32Ed?n-(BD?7W#%D=!v9>3{Xnc%RQ5*r>)Z5 zE8P7Q%|PoBASV=Pi%yqC#N4+>1S8aEfO~9O?g?ZD999idJg;&Mot5a#uP-52(ix&l zTfKEt()6Ro$fQDFXtIu&9CLE@%M_yRl{k$wImX1zFxEk05W%c)A5}@}d{2d&aq}=K zF7LxJmPXp@Gs9;{ePmtmjvPjDxwvAe`c@`ty+m~%^hV%R`Jd7*;SGLk*_SfVY2_YIR7NvC&qQ2EZwo-3rm`=wpB7)V zfduCOwHcPNOelLL*SX%zB}TNbAEyW~u-&8|o!e4aYXb@gY1T(5NBqCGN+HgsD(O@9bp;-7;hZoO_8dsN_ix-FemD}v((e5p4|Ml~ zwEIk2WqykKIjq@nO0|ZY^#p^ajMkVue(V6RDr6pDj84&(xQvlym~zZ~a&Qlw|Eoc)H2#4 zK_BkYC~FwfOa3|v!YH+H{?f`sW-kD{)=OmrZDr;aLe3sDtqjV(N9-0E7Y~1HzDIK< z%axQFZ@(2>PP2pQLl3>~7nhlEUbR#8FO4u6$Fm$nKBTPLXZ@w(L*`OO$7YzfB6@3% zZxv!ZlX)t)m39VV%j#S;AN*gKW@aGmHnJ|d@&JMnr|dw`d>122jCb@g0-9&{h|lBg zd!a?`*Kp)Wb>MVqqaOJl7=e(ey#X9+g^pMBKF!$9ZLDB-B@zqHFJ42W1_wWH8#!p@7n6a6L!#G#-+p z5oBw-P=J(;4Xz$krZYRTMcMYy#Y&lH)j6KJDk`z#&610fYRFnx5^F_~R%M0`4lLg_ z3rLC7o$m`}%S}fK75r7Mf6kQJs0n?7XdT*2eVtu)a()IMjh*_?bh(HMoxTX6slUp9 zX4n%f71Dk-5|xkOZiX$MC5&JMJ_)zK)muM9-$J`6TGk?MliDoZ`tNbPT*mRnMcz1G zk{ZWvNu2e@&83Zwlp}2yik2G6QT=o%!F>h55W`y7h}jW6{>?adP^GOiD@871NA-Mf zRL`lh2Ru72ls!ZSX@px5l8U$~a|^|FRF`Y>lQvJ^(EkqlukHGO-v7(Lq5l&1f9!wX z|KI!1%;Q)((gERt$V?Cc#k`!08}_Xjqjmw^sfe+^buw#Q&B@HZcD-Kr48-2C24Z$k zK2$l!T8JS+60*bn;VVkl1~kw3T&$Gv-xA$HOmh8pepRNU_A>X0uu1SSdMjSA`U@!d z_({@SpDW`O#t3VgJGCxqHkN(fRQ7plos0B*WuC)6ba{?vlY1P#1k@Tgh=b8Q`q+E! zoJ#XS6I6*4rYxmba($9fE{(PnN(+*#2+^Cl#J{;zh;5r0dM>Ul(WkL;-1ASjRx0p{ zyDU}8Khx*KVW!v?D~1LdS|Q}o$;&vFa6*+^B*Dx7kwFX8i`Of)Tk3nKknnw|yTfO0 z*-zbap}fV&N9Zzn%mJ~_z||aHb9{3&$38B;@XIkpIP9jV8XRfy z`rcyu-gEUus0-()UW29Io=>tn`?$WXP(;AY!5N$U(SAltj|NRoqGXUwr)>&EXr5CM&|% z3fXHL!4iM%0t^~pH2N!pc*yMKoQKulA@deYA;Q73uKDIE0VHZGY4|ib&3bsRI@C0K zNHX$K?@)H+qbw--A1|UPbE=$y{G}C`$zc52YKEOc<{9|3L({|@fSA)mDu3k!wM>C0 zSG9^;@hY0yE$7f+De6u+AhoZBn0b;=tLy$0r7$K%bOjl>C|n&tcy8}K#K%DgD^XB?- z2_Jwb zs`rvB-FwMUNTIJK>sDT)2%4_RdX&AKhzqr{RkOZ!MfoFz3tcFAi&x1j`%c&ZnAk`R5r z8PRa9&%ALS$D-0n9JthBbI&XZPWOVHnGy_o!FCPK_JVsgIL{0IPJ=5bbPR<$9kmPQ zm=n>)jg^+5uxyse(XR9x4Ff4b#UqzLCHlxBu=Qdt))=|j@M6x>m-0cD)UtW-@P|*pn(_qzKvR4_ z&NIIf;8%_4mg-D$)Xu{QROiwCw$8y{HAim2iIX@7f7K-XuCkZ2y*4A|Z845cxc7ca zymm&~_w=;yOVhqD>Hc;vrru%hOpsQBtm~ZMJWc=&yTiG)-EStuF||t3U5H-kbW`BL zmrUm-GG$LjTG04YX+fI?Q7^42E)9iFjFpB&sKXe$N@j8lMx?{9Q@R9`Edf~u$X(qa zcPq#`eq}9Nzb#r%$pAP}lrhCasQDYCiXbB2Ht$rDEK~OVGj!WX&*vLNKJA6fjRl(u z7;V=pwv#j}+9Ifc>`6mTL=odWq`bPO(VjKi^X=Pp^8F+w*)hULpQ-WPrfcxG=dwu3 z7H|0owrFcE99i_sPgZ0{zdW>xpF}vvnJfzZu%Jn&M{usW18}|Hc-1^d)uqu^fAq^_ z_>GjV7iuBS6$@dG$3dy1ol;ikp;f)2or#biQr!z$8Z)$=A;3yIu|b>Ze58&DF|KbjpNZr_X)aHoi3|2Nvy-Ue8b8;3 z652{ACdRzDTi*|@wZ^$Z8AQE-wB4;f*N`XjmrpQ?#x_yFq8aA$3ova3HOUz&B zjvB0;K%Nq$K{iQD1NgtsoV?32-w7HAa}=x@?8~&wt|Z4A9;G3z4UhBdYi^dn<_Bp{ zbHkH-nssQ(25VTh5%U{#1hI>2c!Y9fPo9=)bz51d=*7vqV$@AG)uXFvGiugx_0JuGwq;03y#ZxAQ2ikt8XB& zinrel*+_g6Ej#E>&gcj<9ER_<1-F(AV^EDbm$g7m^Twx2xJ!F1tuwQFOBq2a<71v# zbA6Ij-h2aZq%SNDFJFH3wV_h{&n>@hY30?Sh3@Ao39IpZdiEg z858P!zNH!}2;s`k<>A0j#j{qYa)LRJ%G~`@j$zfC&)HP8i+BqPT~OS~P8E8>e zb9K45qCB9Kve$BW9?Y=I;=$TUwZqNBRLdSVNFvN#;13+3?!jivFF7ga*Y-6_&Pa28AV!LO3Q3rv-R$Dwp2#;tLYQ8`(4x zA9{KW)yc?O%7|Ad8|5z&3;E*<_d6W9lfQYPY(qDFaoE+#e*P+-);NO~C7Lcz9{pXY zAO8mMuaJL5iHXjvsl~ymfrnpCoatONHS413PH<{gaC-3@fd^ks40UFe6bDNr^*CPG z%DSk+36^99D>T)4S%gzojv}`B>c&~bbIZD%8zBrLk10Y^d_}LOvZVhj4Dqs@8!Bu( z>OfY%q)6e#BdwR7%SH; z5~Rjl#yOw4%6!4YYE4aaBiX6@rhd zWb{b(O`&ArJtY;>e81w~JpNt7zgzgXhJWk%N9jeS+}(=?&ZsGV-b+Y}$e5Cw7+2Kc zwrgzSH19iOSx#a|THtG$*wchGf)Dnr%fiz#Iz?(Ly^Gcz@`<#W{vJ|^ExuFbTO}Y9 z?YG>ixH@Wwno2I4Se6VIxGC!TECag$G6fH5WT%;uE0mj3I?VdRP<3l(-N0x~lRb$4 z*;EG7EE0e{>dx*;UPY9$=j(yFQl;B7Tn)t#qmffQ?@(wGuT*8&Hg*;-%UOxvI4Z)J z){N{+t-G3Li0GgT19(_2{3>c9etJy<$;qRri>&tek^7o$cT=qSn`ON%W|11^d4AnYv;`>R_Iz!#E&Phq7frhY@=W zt8$q`o@96@3=DdCDc@Bcu^C-4o(CxFs50vzLgLWrdvF+fP(~#3+YLU^!%Cp+(4Ku6v_Gbt4_|puFjO=3hrQB zqX>`I;Ne3=rHx8&5(@~JYK&%tjL*N=Ym89rgF4lUOZ@;~ZX8hfwdC~1-%~0+TyZL*#%MsBn5kVmKz{|!a^5C)8OW54Yaflri zX7YWG`sdh?vz=X1AADxi@0V<$4mOb-nG{@e;15FQa;`^%CrM|%N_EC=@t;DDy{0FI zw4eS3T%Ni=u*sVTQ~OF94tj`d9Nqt9t!>er{-1?kBp(?BUyv9TE#_$}Co5XF*cTcq zOqf}IIzz-H9Qph!Ha7%aStdzswM#Y*B?o@1zV$_Nawdd56jwo%UwBhtV=;riJO^@= z8?4+|prB8q0L|XMZ^ZzwGh+L$O_(m)G4=u0Tp#@HOpT7Th?0&k{N3neDZv*WVv1=i zbJwzBx;W9vGFfbFk4R#4va|<_bdkNve`Xoli;qZTbaJ64oj6Pv3pgHkWE?w>C{t=pA z0$7}MBJRkcGhiRWlVEL5ZH2j(8kp-oSi<Z2!ne7xt`;Nda6kQ4Vav{| z5w>h9>rRnxP1*6iX};Fd@p4E}67u6uAt6yYv3fBvjd`3H?qo|Bi#4z8Yi*?q2f?tk zmDU{s0b5H~@cKnenV+`O&<;${Ta~Nfk0^O%v_|Dvm_ecXDntJ9_7w#=J=aX&(fN%p zst_t@%F%umomBJkKtR;Ft9^uF$qzssJ)blr8H8Xe$Dxzu7^QLUA9Egs*zac+nu4`D z)BT!*88*&*cX}%M3^U3mXK`6!lS_i;dN8RuDlAmzBI5Q9kvlXWs>njIe=Owe+XZ&&&PNUm6H$+YT(149rXnQ>1427+d?P@M9yL9>$u8(lRWwSeaG=|=9xo$?Y2$TrX1%#OT9P|H+) zLRZ%a-kA#h6wEM_`BWiNtNGc#J4G_jLel-`Z8>~by=}EnGAh0OC9*}^ghLIcW@9eP zin$6j2#;S`vwzMspZQrG;=Iz5mX>gd?~!FJ!RE3(!Hw%=Em{`^=55*wwVkNJM^=zh zvy>lGh;bXLy`s?a_QnozK)+qd2VWg2+66GglfE9&}c!5_naM?sI| zKU*!AR*G=Qe`Nu1=ne9YW%-7)3ZcTt)zC)XHl(jt-HQ}d=l_=h(Xsu0;#h55-nyTmF7=M zVqIgz9A==o>}~Vj5n&hh9ujuJ+ovn%yddfq94L6LbYE;9M~e#kRpAUSu3W-W8jKsP z8cQ&VPDrek$cE?Da9}@^jZrSzNd+Z72+w_Q_A(os!&frAX6S&wQ zdoH7walV*9O-^um+`Q;uW+1L%s zo)7FtB&1*u@||376qd8(r?fJTD2B^)d4DTyP(lmb0a-OO>7h%@>R4H{<?H$c?sP&sIja;3rT7dnIRZF?_6Q;q<6L#aG!qSWNy7Gs5zlG38 zc*6^!FjfMH9C#u`2ab+gB)k)w&B7O!bp_mjJyV@9Mt2PFT8XEVG z`Ein}xfJenruma6aER&ajY0eOd#Ibow5Ud+!JQI`wUe zgNF1PBm5QWq(fxj$4e8oDI9NLOW+v-RVE|{#rB`s1XK|bCfDCb$ee<&s`fj*c<}3N zkcN#ux5}*0Jj*rzc>S(cxXw1;Y0PJp8Lp8tZD#Y3{1sQjx$WokDOgz}J)~KRxHnU9 zl}T`jpWi+VfGYEWeA6K@EIV;~2@>bV+pTqhMEQ89h#oEA6scvo`i@%G7|Lqj!@vo| zNDsnQQdEdO0`Xggu!V`cT+bUPkc3!^bm=9#>+7TMs-LgP^ zKm&ODmD{O|c3B%*K+ft3v!_&jhv{F_qmbViEPc*mkLZSiY-vfR&#=a zG-K~zhZdP1t@Uq~#Z2<1hA%0Bqv@d=#bh*4 ze~@6%yh#t+|H`L3)K#6;Vg?QZ?tw*YZ<7>VPVzRVpkPjNnLjyJ0B&N?+ka*O(&M*C zyohXU#*8phKh_89)?LhrkS$5^U7{0L33|-(Z#<+2U~}`Y(U!0?`_s-OOB~Id4!zlgzBbCdD*p4CPf4Ma3#;cZwuD&5O?u;c%mlE{Ny83(9aBH;uf^g`% zA6yx_=DKU?k3OMgV!VdHi6GazpNui;$_FV^J&uq}h#X~Ly?2TvQ<&`{CMtR>#vPZ7 z!8Aq*rBhY(cL^V6bG0C4o@NbAsx5)jyJ4zRUJ-Q4ab#Ft5)`0&1W3!ejR$(0q@fQ-1@)i*Fbk8ZyV+iI$L1_c^LB#8;0wM(pg!sCosfcL?Ih<(hl;3>8=@ zg>d)UhqtB3*U*(}HNW~73>^(~)~{t;OeR6{+h*WHS`kG|Zsd%c&R4cB_V`M#lF8x@ zfj&#!EV6gZweX5zeBVmJzEBaB<#A%REto}n-Q#2N$I=2DAXkK-w?1lqPc6cHo8mzwmi1L+%Oe@iPoS#Gklik)pe;44^;Zn zoHJ`_WV1E1IDW3PW;WzHXbv*c-KANb7sj;{roG%hSw<;vy9j9~3*`&kA%w;hh%~`8 zd>o$RoZ(CpJQ-a4xD*#Y&MdnMVqy}*s(9~DpwL8l^)(fw`pMAFzf3X-J8pf!U!PS7?^WRy;VZ+ew-_+Z|I>B}E@;~np zhF*zQ%sBy}3f=k85HERDcbG1ikq*G`lbqoWBV*N@~^44k-%y;Tmdr*Lj<{;uLT z4Wz;Sfi0b?=2sc}k(;QOanXOrqo)`hX;q4|*f!~5NE}_se{)R%tCb?c&t^n#^Y;%` z+h%OtODk+M-gVYU+mk=q!>_uq835{0#}sYTB#k-(6GzmU8kh{(&SB~)Y z(l6K2aap6Ke@{xk$mVtI4bdd~N`oyf{%=q%ued4)D}k!q;-Eh~*j@%tl=?Z`YNgFo ziYxg`!&dB`50IWe&PA@Bfb_^dqh*xx#n<`6&8RZ|6%IYX=V(bazuT;b8}FF~k5 zi_sHbHI?OTZNV6mZkvhL$YU~Ha^U+V0%d#PYiW546{bld>=Qmj87`qg&VWfs9G(8W z3Ki-X{m38AYgJoUT%tacY3d(Sx~2DC1vaBc-^I?sw6Jjlm|?EsB_HYP^;)6#0{L5@ zQ>vQ-+JE~&YFocp=DHufq!iCmX`2UH^J_{W!FGg8^s_#M#{J9ocAXi%O7*aC2V@Gw z#8KCZPNB%Juju6To7-gWd|{m3N3CcdvPQ+HVT zlSJ5KR{!H*F4W-EnX%KU+EMhzTVG%=|CTT7jhRl>YfjnrqFrwtA!fG^@6~WBZoa*& zZn&^<-xt-W4l}J*{vIIJOoa^q*?O%09ZCs!;;X9pHInKj$+MQkPOikz!7bo=D%Oik zSG?E)klXMHUV~bks!hi>=sBnC$!~7Zg*3>aB~`RYRhb^A0tas)&tat%Z$F)7l6V;2 z6ih%C&-2KP^XeU)P%w3A(kx$Gyb3M|GTv6>tveO&_{~Z*)uJoAe4+8u$xF|o@LkOf za#v$c|6^y;er{e%HZ$Ul&g6}K$+!7F3Ep537w0wKBQ-GjPvYFiX^?=K32!PhVJi3# z%$RSErlEb!8nQQA&}vlGWaD1MU*3OWH6;FS@AWgz0LA#9Y$tqjuaJ5Juv#68jN8}B z{XmB0o9b%VS4LJxxBZeG)E7F5+cK<3rWfW^<3Zc+-0>vQ$$KB?7mqF9s*Y~`H(+vE zc`V$TL&PS3)WI+2Ny*S?^+%m86^SiM=yF`SMd4QRBe%iH^^0yRkm|w~AhH6eK>e?Y zso%#dX#Ay!a`HWjMHaYI9Njian|C&GYcG>M9%iQv`2>k8t5N3*A{(XMKNK+bMEo6~ ziB>?9uZXS+`a5Bd#|X6}O&Ga*wSi@0fai=hib=>p9`r zdQ2SDiwjT2gN^GO8HUhzc&JCO_^6=3`5l)aOEJw!21m>5=)(7)JW1#7{P$PrgSom` zKlqcdoAv?`8mBy-J=;0r=UjC*r>ma4jlEK0#p>emg*x}6`MiI=@I0UADn&*pXc{%* zeH-CEIxoBmO3Tl?e5nfTXPXfyTsk}0RsOQ)E2NKR_sjh0D898KbaC|73S1+>w)W!R zz~UP!!Vr55AM#~>ODoL23^vAFEB-gI<6W@l0CU>rD?g*OT6Cbq?+OMv9j=<_ATBaf zYNBQlt5dghPa#ka&C$9F9~wf;dH_t}tr5C8_yYjZ3avV1Zr@J3s}AW6gsEa}i*>jV zrfo~piblvFx&b_;&^+TyPj(rCQ^Yu70x3BpOM^4N};y#m5MttD;cX`S1GT%{o)8~LpsO-yW&h*AGI7>T3 zTh;Y#E=S;PGSzW2TjT9@*AAkPY)b0==xeh6Q5~QziKro>dh@VNWVxCN@pw&mAEEhZ zUvgH;J1ufHv#CCF-6B8(v*sE;vlV0ATX=3)>+){?e zPaGzHL$HBO@xb%`vik_BT;KBgX?e#nAdL#`=@)hLdUCN9vR<0aA9pc3x;AH}t<7IZ ztThllH@an=V%jN;-&gZwsUkFrN?eebe^$wg?Mq9MmGlvPq;nYK`H8-)&|g=9OW%?p zGi!NH#+-{9xiJp+l^f&7xeGC;1-`VG$eyDzi$Cfwn|)wB<6g59%^Zw6VBao~>5Sdc zL~P^3F@D+8Bp}!JZAQ%3y78#miAoYTyP^ER^V=CJ^Gn1|)omIrmtywJgbwX~r(F(C z_y9#DmScJ{e)8SS6AlzR^q*fP*$MNYFDu{vDrq+ClL10%ibbR<7h%@fYR;$f_UEXu zc+ukUSg)uTX>eLmZ~X&u8!F6~f6e7fg62M2#Ngf5R6ehfeTPjFnRXv%O@xACXtMWk z%Io;cZ6g|;(+hJpUmyf2ZVJEpDrtdFi^|#Y3gC@{JE6%26laLiB zhVdcpGP~jMDkq-74EB^L2DPVIS#k5HD5=stmz|jOoCqzZ?CSMnB6Sh@3&x0T;t| zP&5XUvZ0hNZY`bXGryG)kDJqI6KAKHvA1GJVr}z2dn)!?>|IwUbr1BowqHuz#M+em zf8(RAK{JtG5rCb@9LXtX?{ZnFa;?=o;}9;fgkxOrQ_)@Q%)&hJON3MKw*vV@3evf} zBkS_cN+;amyoo9WIrfu-J@O`qH;Os^GQvMVp5g4mhhx9M({Dvz86N#`f5UFL=vR8a zd?YJYb&>A}rIRn0$c@TP=AEt{0AuSJQu&S#i5 z$IaiD(BwT$Sqyj1=-&EpNxSpAqBl{ZgMgpOMwZ?JCz2x^BHElMuRW5)XVI!GMlDj@ zH=I!#DekSmzVM@|(fOFVMIG;RNHYF!VC><<%DSLi5H44*eHoKrxBTXi%ty0C@G8T~ zLytX1;mu_moB^|Uabms;Hmmt^^}4g_rqq6r)mk#o=VZCOK%oAg(m+)S4Ak%A+dOfF z9H0XAZxX-?1X^?4E@;j8cd6z0;wg&*4bN#7r(|)Ay2{WLeH?U+l|89CuNh@e+8y^c zER17in;i5X7skq-Yp#mO=VJ50eu!8&(!8=o?E3J}r_o|KTf#aMmmG426j19@KDW8* z0P;*pM^`+{S+PhqE6h%VM8(Qpa~eeA87te_e2)&SwmJDHI^Q7S=6ht&%}LLbML${G zWNmX|8d zA8J+9*d`EYlD3=%bFzD}TJR4%zTk{AgAV@z1+nF&CQWSG(!oMISfFCX>YR9s1nAHJ zl|0|yKIbNBh573|&*$?zd}!`DXTPnz_S$Q&wf5R;A2c(~&Eek%lAMk$2awVY0zcn1pG;bEbGI4nS zqVcKS$0@JVVO0C@Vy!~1%zl8_g?MmrYAX%}uHJZ!|Ag>|SLU{DYod*TT3n38N4oS^uEk< zPByT*@~C;*D$0Hp?bo7=p4mhFU?N>sr4P*FHEHU+`HSRYCNpT)pgbU%L9s*H^W+uKwKLwXs*0^GdQ3>958Z z1@n#(cJ$op$WZ<F^eQ=kNf6R<@yLa>JZVN8m1O+Y8*-d*Y)S(6skdxRJ#L|zf#D^OGpwU42AmJ6s=PJDTT^`Z zPDiZvWE5F7sMk*c?my_NY`>o4zhs@`VDx9!eBtjtv$|&WHJ@p{=IU|yUYi78F=fUH zGjyX`d>)Rc7V#nekdpJXkE4EFOtP=?jZGW+b_Aw zPX1`ee?7iR$7&S1XWxH4z8#G5lv<4~dKn6;%t6s7@QM8_Q6;_n$3_vz!G|+=%=+!J ziJ@uH3AO`E23ZD*WXBnFNNIdDpV)S10wYX{q$<4-#15VVm*=1G9QYl7 zm@K}{!7sBc7s%!3KeuH^w|@%-8%cl2d*>af21DNFIJ|gj&zw*6*5&ogxwN+~zh_Q$ zZ(X=&&c}P}B0X~|d+Vn3%&F?FBTr3l-L#%Lv&;~O1>)Wws+<(p#a`tsJ=g2^+XBuC zUmPF7!`9T5dW8bIuGm}f2u%mT7eA-72b{d$>3xNAIXjy*WFVUrL#kfOfL(e%Vrq)L zgv!2Y<`lcUj6MANn6s`l)LPF9^usfdK9`l6no`Ln(QLV7yXDU@tYv4qnNCp001-cTU)(_FcuWDaPSJ1IB z|H&59l*07z>m3MCMAb;wq&m+xb6Pp=5zBIp#pas1+r}Axm^{zcM4qjQKKI(QHL>UV z51u}2{hZLVHHqh5^Ip9N)uyJfHSN|E+Lor9Z>k-)$=ab4CD@{!(MbH;eQG%hWh3^i z(OLhUD>;YmEd>?$wM*upR4BBoTKet7TlL&}cE-_z_iff~=+?eWvQ63hyR;pM?Anu0 zzTeyrI#B#Zw|^g^-1ctDzVeUyAO|zm#PbyWZrcZ@9{RZIu1cux=2cCw%wRGqu%DE$ z1#neLxVPUP6xBytS04|uv_L<20C^vJ11$2$P2fQT-qQC^w8q|~_xCzDpo%?;(s-zM ze$7_>?muj6Jj&zxwf4k~eb*-c`n8vGzQ>k25|moM_Tzc%RiX%QwV&7nR;AV@iZ$K7 z$gjn(t~#&nBKt`#sxe;VbS6(L`#mx7-KGD! zCk#yY_w7S@keFu3e20vlnyPVj`zm#1y48TUm_Gx73 zOYQAmB}f7)P5)?g%o1qkQGE``)X(E~6NLxp^mkh;X!D8GWA{|*e+%omZ;{d4$Hw1= zY`lUTy>??PrVhm?aJv=qQln8>Y#r}Kq23GA?fIrve+w)7!6TqnlZYJd@~EY1&QFX& z(e@ie?Stcebf-@M%S(}#VSPFxTgqT75~isv)hkSg3yK4ai}xUy8NQl{Igz2%?Vgnb z$dmMAsmSfFJSkIAE>mo%oBL(Pu+)Wyy6btOa-Gz&Ts7OLK)%)RUkqnG{#;O>v#yDtyBg58--TL4x+9l-uiPlyc$`^{%jsWJ>V!c}R)(E0MTZeq#25;q&@N?M|&+ z2jq+q^i}wWXkpshDP(8V8I(@sijbj1>_?8&YF6)9bg@aF8 zW$Zab->oVq4gB51b~(Pt%<<>QIc90Gy~N~nmZ>3c=GQfN*{SKe;`prt{>g`o-GgDd z_wLwc%_}vf(mj_h&w?fGnNkp0q=vsXrK{-AJWL~qr3lk1vX%^u9+ z-Yr@A+C?HV{aYL~2aq1LOTG2k`+R7z_r9aB16??D87Fks>aMTHEftR~i@J8ZGuYgG zQ-{O<$DEl@s<^q|_F`c)Q+j4^vwdK>aeSw^D!Z=VzKc@XDK^NV^XOH)AaBYIdsqhw0+w>yeSG)6_iiAtD~zr- zX}i>U^loLhZXlq}JDmo&*Z!jQov(yiFATswh*j>SF4BjcmG8k#T+83m1!!SsE2w07uIHb$U7Z^M@`6~w)yozu6{Cj)Azd6F!Nc+8&?~!_W(lYb( zgOdpPBsTuj2QAsHZ-0;W+wAfqvP@wAhiPW-%r%L#-IXwPs3aur9c2P~Uu6l%rLX!B zUjnXu{xNawpQ!u`<4#95J{UXAmIJq)W!99!gA~62siKhmR3c)-ycNti&_kQipck*?4+r%_0-CQxSer=8Bh{XOFHdFMz|73`3%C)X&qg>$F zyetQk@+NHF#Wrslc}=5TVA`g5Px39;NAmAWR48RUVM=A;xRM1+?pV?vrKU^dI!jy1 z-}>WgW0#lgF7W?hWYeQAy=(TloxIRZi-jL2^%u(#pLDP^JBl~ z#ncnwd$2w(vfAo_ZLAiY=rDLy#?0f|1|9I^RBzooWRux2s6bniaXA5E{qbPJo0&=e zT=qIuy;V6Rg2AbZY1m4gGnF#xu4Q-Zj>U~EvJ2^vVqxN%`Zz@4{r*MvB43T)@-x~C zgk|k*j0?+lcgY6*%Gke?G`cS%6iVu!fzis>=&Vp%6U9-QMw*ak1-5tpxtcwCl!BIr zr-|wAzKzH83aIWEIeq6G82c~TTM*Nr zE52^z!}lo+j{f+J!?)gUQJ(O&a*9wMtn%Ka>&&Qg)*PiETmN5SwVrFjLzT%Gv^!K;ATxv8 z$acK|+wi7L4?zYZk0^t_xGg~jcGlL$R_T+DqWK9E4$(7rSGqG095J_ayfU*dvqk#3{V2m9 z_Pd(Re!$Fhb{4o(-K7ziOC>dIU*@~7xmh_X*A_jrCBB&J$-If4Onq}t>uK4uXiO|K z`%xZXC!y?z|Bt<}*|@vX7NiMVeg=d2B<4uBsdT7DV+DH4^@Cd2=gzMHGc~h9p^;Az z$-!-!JycUK$cAc!e0~}yvT`;2P|b2b^-4eWDj8vXSzZ)$wL5g)+8?# zF|-z5Dm!EAJ1km~JesDY9R|yGxGPql_BjmYhgzr1Yn`5b-&VDey^ys#ZZK~SRVQaE zkGRx;_e}_Lt6))6S}&Js1y4??fU!HHGp_IGU0;9e9Gziq;wKW$&$Iu9@_x$e5BT@@ z{M*34&+?DywD|#A8{^d8fN3n?U_3M|c*j%DGECgOw!fw6G(3}JZ3$*SxZMJYvsO?8 z`3PyIq5rc!?zEu#YrBt>j%k--j0ttUO#vgAOjXkI1R+vQ{$*tdcx+{e^#f@N>2<_vI44D5>=W zZ`sc*!;?b>8W-FhPQ684ac)e8TAvRvEcd1-e#{^Wf#T&R3Lt;Oi@T^murRFBukjT- z#_9H#HoSRk_nm3&AJ2&>j?i^6e_joF0}>K;I)|rq_gy#Lo)9V77k*hxx??JT^E=*Q zrZFBE)kDY~qB+afF;z!+pZS8By}2A|=5#`w5mwJL(i307;@$nfC_#*Y?iXl}xGxe~ z3U4dExFLiD#+p#rUB>g)(4ITfvP`EBUYF0Bx+E1fL*e~i!)aFGEZQa_HAD+M{*pW3 zym85zU)lY3*16MwJNpZ}`@J9)4L=rsPSF8Tk-V0O;^ythxk_7n8PDEt86eDb3RB{ooRi{8uKyZS=a^a+k;$m~xrQRM zG)8GNgG%I|6nn@Db3gays=iMy2tV%h$J|c>w9vBTtFzp*-8B(+ew0`D%CFAK)Wj~g zLa^jKXVBwL2%LC1xh!!`vRq4Ks|NRY8=G0(&#pUL-xAFCI)Sa{v9r=EqMcLR6-RN; zYlynUI;%bE)^S=m+W#9&MYxll@O~jNOEx>V*)t7Zx*@s-V{){l)=SqOy>1FOU{bg_ zTGH&vF^npjaSkKIAVmk&k$w7xac_l}iQL}3`?`di7_0TLGvMYmw|n>XBc|EoG}7vS zA(IulBu#Jr^F9gU7LNZO>pwiL(RS=|vq$6q|Djv|n{^+j%Du~|6VtuJ-!{6kXQz46z#^9*Y7 zU(imyZKvKBfc-l@MmZ(;Ww;aK9ZScG*$AZ<5jT!A38)TD><{lV^CMx*1iQircrUyB zxdO?x?OC&;p1dW>d*S4~*oV~RUJku5SikAER16=R6x zOjB9>-uY24M7_uWVymW!q{Tj;B&AC<6y{KALnD)9e$uTeaGMIj-u$3zxA|TBl3M(` zw`%ddZ`C3__6&N=TQ~Zv|5Kyi2zUd$p8ZJ|)DR9)Qg~Es*EAKx?}ewjOHwhyQC?rN zGhLJHn!;+BAA`8DrgB#81*sU%itc@%f?SmoLeHW@RWqv6r?+Q{`Y(lxQ`r)bQ_8SgnF9-r}=nu2ug==IaWU|{sR z70%jXmO!_KHbdB5Tj;DU(rIYurS=%mmW-5) zrr*5oLyT|a#~khOuJ|EAaMEvH|HtgPDg*Q=#Cfo;NtN2l5S^`Ffz6<#rl9|DemD%n z&?z>KwElmB!&^bhUxCAG#&LMve+P%f;81k@)@V%r;Qtjg`g3QL`5e(K=Qa&F;Im+M zOw&_-$9a4+<5GySA+hm^NKU`DKQoH?-5d!8A?bz7Y;Z(E{ywG=~)cLpVyB0JrM5$|t# z4s-}sVs^XSx=1!|&M`ZYm8_Tvj;uU-sTLH}CO^qaeeRGbl#17R&%Kq0J7=3h~{fT}5cD*Hf?$A$i#Qqd4zf*68 z_21S{(WdX{Cw1Vv`YAqqmww6wp1Za*Q&TZ>_dGWW?&_mX--+%gJ74tG)!A-SJvyl1 zbUzi5v1jvQ@71UA!5vuay&3%eKKT8k{Y7>#{nom*d9#%sFII=5V`rjBDE_Rq^-6}> zu(s&X81bH_Z&+KXhpuz1AoBsTV?fatUzl+oKES6a7l295!Aue|Tl8gIYlY>_=qj|S z#CT-2m2xpuS%{n*R59d8)#m@ukW&#nam&N~vNI5{MV>faXJTVn7vqAXP}fxcM!Is^ z?pdlv!)8=TdSSFHYHWS5zdCl%^wrpyXX&Le(u`UlZDGu{k8_-zOVVpo9k&nJ@Mux0 z8*lr|Lv=QctJ$Jj`kxQOdgJ%vy7fa$KyF>3U$6aM#P^u@4g0-_Y{$P8^-FnO_8VNI z==hgnehKgM_FL)9-9vTO*x)W)kb`5BpM~ty>s2YEQ>i`}O^@{aR0lCPM1}b78s`DN z4OJ%i8_J&M>yMDhJZt!~`u?&-&ciC0*S69aSu0Fcq3g&nVHOp+Tdv{(Vy;sELPJ%; z4L`H=W2#baRpn6CZ2zUmd?j}LRfC{F6pNj16;jrab2Vv7cDJnJXE@Fuu4LpdBSyTt zNY{lE)fCV_X)PA;*?skouocU_TQD0z2I6%`#Qx$3LfjAWv5nnj6ZG9}l`P#pI9m z=7w3ub}T%EiKHvV3Ms1!M`kUZWzRMihB2GReZZ*aTt+p-*8RF8bxtG|N#C!o#y9C; zpKrO(>F69`vZ8cmiv=HsnEjmPtQXtUXU(Q7!6t9q8H;qza31kPi?;b1M7hwM(;&>i zwvD{|GV7|ySaXPbRP@Dcw1o&N^8TlMJLZ=bjIny4#Y>G(+d=5ql=JYmHX-zoC$%IF zc*|rXz%20y;LCnwHs9kv8U6a?WvU`>K9-2}mh?g!{|P^2*&wXmbH6@1T^KNCShLe` zMley2>=&{dje;pJZ}s)9Q|gI>-{N!?C_vDF=So3gIV#9rDW5iWhJBOEdsSYud%#;P zL%_#}>XKAN8x(w(*`j)#8*#V0C@7E)3UEEFjo+BI0ew5Cy7t#botDicOScvB2K5l2>KxafgtnTY%1GHi!@Db^v%m|% z!CLvTcH_zQi%*+Mc%YS|>^|Ix`BVY3pm7yJ3J6$anu->CHyqFiA_HFkQ7bma%^9p= zRml$uMB#*2th0P+*B2RSnK3&>JJp0?2v(ELn|=F|8R4d$*M)T4+jed%_ItlPGIln$oSp8c z3bqMuvnn$4NodinDWW@CqF4hT5I$;RefB3&cDLS=n``U&DY%k1L{s2%&z{)-!*I5T z1_C8igZ}PG_|^THI74nzjCsD zY)hD}cT)pMUIvpkW|(s7}=4NlC1&p|Cb&1M*Q1hRSkzYEXh|0O);{tBRo-+RB7 z!1RA!7q^{yr&{#aE37uA$8yC*F`uHc(L6g8!4`JF3w@iuC>EQ(M)_^voiJlqHX>i+ z)-%%gi{`qf8vE6FZoG=?Ih}_d(8tMT%;hQ5V~6DF zw$sz|+S{V(UW-)QX228tHHhwtd%O+0&HS?d--Ofi%dh{4wSmKPy5hoGdDXKISPEt5-1)yOWO!SHUsl+`^b^~Io+|6b&+ zm|RL#WzWG<*;fy;r!JJ{YhreAF62={)Flor64WEW@N)o<#6wx&ELSoE_1Vd zoAKw`YXu?sI~Ad{cjS=8uucO=qEwW2@Fv4ZQajy)N<| z@oQM6Y{pR&jTEP2OTBG=l3iXc9WoQ|7qj&~>x)(kw7k}|9REVQ*~e{iIr+xg?pez% zA6yvoejqzwT|%Nzl4W8c7dwNYsdh(-AQ*1V)g(2oB5D4$N{VmPRJFX^XH_2&Y?f6y zYngWp!PP*4a-7?Aq`VEMk}Y-~?jeOByhAmTVIezb?UnZRTKkHj$Ch>0UadoY171Bl zi)PDS5`oTHdu@oxy>^wKb{9sjTpB4<9Vy)RH>_`8fPmLWda%Zyr40E=B^sBKw}*C9sC&oz4*8fzxG*x8XU z5|zajWY$NFk%$n#cMpphIBkpxA+6K4S~{N+h+k2>tjFqNKD{pWDZ=SOJmCg83UR2O z)kFv#JJa9q;`P3hU$rWZojLpv=&-afCm6Q2kK54#*ED;USz6%Qkr}FsQXrHqvZHpI zsY|+!8o&bL)B?URMzblA-V+_pQ@?A{qJ z%iuZJ1OM3v-(Pd*!;XX~Az+%_@ykxJrqJ-h7&+Yfghrt?l^fS2kzfO?idW`_wkeud zEw>wDLbNXlncFqZ@Iu*a@whlTRul8r$fYa=T7Z4Dzs-VRdsJe{_@dl|kYC8c0@tX* zT(vRHMtfXHW)6!)JIgE_J};6^Fu{vlD{BpfzW*aB0+G=lOA)Y=op%Uj$CkrKOgpzn zgJ>rBJUNH+%)dzeLbaXQr`_4s1aa;8z=9Q`(QgfA zz?R!d?|!oNjCtuT-{LX&?mVoQ)4Tj!u-Tbb#7PKIwn`apj9PH(SqD^!+gN0bO1bqo zq-j#ZiO?uB)}X*%L~QswD$a(1Ngze@C2Cqz(f;2@!}s4siu%El|M5^K_5h3?mB}^A zuMLaF0yQ)4WnyexmrP{4912xHQ##*FMUA6P z+dK;^0C9xfya3)r#2K0da>uu=9}4?}wd@Q+itG_Kpy4JpD7D4TVA9_?_VsXc|08@i zb*PR6`RJS0KN|Km<-BS(65NFonk~22_63ff_?6ccWZ`YqE=I;kU@6c(@zPvFbu1Zo zS)}PkjHS`7dKPcP|G;?8-~+f!cB^TbtZ%bpfrZ0)R8WRm&o{A@a|8P#XR%A(%m~ml z7Z?q{NGhfYx&Ozzf2q>frpiq%-VIp4Q@ENdyw@Vs&Placv3T!lNkkjT9*fg#M~x- z48SNcMy?QBtTho&28IUrk<|%q_O1Z0nH!RJ)HoH$)&S&%2cVcP4nHO$};mu&Ce&O zsL(uMsYq_wCC|}nVf?{I@-6v%XnR0Ag^f!sF{p)Rag))2ZZ4YChB@BsvYborw>8hX^y&{NRR zQ$(m@R95c)50QH)2Na}q^#PUBk4#sol=jO3b?jL>ckQo8^qy{Z}7Ic}QjfADeTkH`Gh^JCxQ)J08 zC30l&Tn3Nvaxd5L=u6VAO6rU4)!00EXZZvzvK~8whtS;}u`xS&T~Vt`+ie^HO%MIRp1eUSpkw zpU=bkk^H(>#n@7t(69nX3jn&X9+%_S_m3SP68<=jDuly}A}gnV%udmr5k5uJ)-v7k zFJ^uLOe*1C4231#%QTnVMRs0t=x_2gO!>AR=HQ0Gt(wrUtGoRF_S5htO+$Zi+qM6B zv&-2vw*N4giMbjQ`1nIUg5Cw#5sM*qm{T5cl5!~eS43oufY0$it2f|VkeaQA8A9>> zavyCKs>HO6&p*92CP^k5#GTKgN zVz-G*DN;%eNnKeM|5}8MnvW%R+EzgSPk9gEC!%xR3V#GnXMxd5J7*u&NM!At-8nI5 zQ|2Cj&c48${S_^x#^>w@9}VVgs<9c8pJl86UX*H?v++$|oYa7MvHwrOgl+yLo*3Xo zj$YT%qNE*OW$bm{$m_fiqL~e&6{yn#P~SVLrun1*-raevQz4gFb~%3&*~QME;;jwl z-zH{bLH7&sjS;$(&URfO@cb$t#9>9f-$zQW_jGG#Zbo`}*QN@F_W~DPEj8F9!VoJ+ zF5 z&ENC8mGsxUuj!5XX(Aa>&Rg{KQ>XS+SMdmY-%!zjb|!lIkyCnl;h*udeeM=9%%S|P_ah?rW#*NdCr)yXM{Ss& z>i^BuTp3JhGS|3PJupwr+?_?I7|K_t@S3l5Mk_mBs?uiXu;feaE#XPz%e8^B)ONnF z7kvV2V<5`2F)HRHhZv~|H}W{493ZhKQyJ7@sAzoqEy|t7V#Q~g>ZG}`!0gH_xw$xS z1sm`lp@PhU?KpogGQTjy{^MOlNL2}cQ!OUBD2gpW_`ykS-H!szsIER^HwLqf=1khv zDBWuJ{LGC>)3LqStx$6v+bi65&Lx$FTF)7(Y!vLyjj6o&cXv3?=edpTh~ub??QUZu zgC9XEclsk{OCWvfl=96!7Rd;J>*cd<6%N^1Q`%}a#u z<}B$Vi+Jd`*H$^wJ)&&D6g4vQBrZcH10Jg8i?$DGb%p|*4M zDIXM{QWWQ?B-L!&4B_WSnhmnB30nzAo|%27d4%99Zto^rAFiawGRp}i+Z!g#o73rq znC#6*!_D4?*F$uM10;bP5{xqEM1==xX5;C5S+BBDjCuH<9<9Wc)v5KyxQqUUx*F%r zMAtp|z7lJC;}qp1dIDjQ+~yuthRc7}T%1gIKo;@hL? zms(#mj|T!!dH|o>pyQLE2|rs0KOO|~`DeAt~qNSzI4^?foQ=;~8q^?rEdKib(p~~3= zsl~jBB0)fm+L0;JH5$Elk=Gd%bvEbPKgJcLv_DkqiMDi8I2~S+cc$AcH`mO@jQZ@> z67B7<+2b}GVtuGRXbs^dPni|_OvvmZTE-qbmMr#r7(92yf$rVJoXp&6MbXSgyUp5l zmRkmWniU7;_MYE!UUm2Gb$^swaP2{Gxes)j+Cv=q=bi$u^ILUewTDrl;OR`Lsc0e*TVqr}`U@O!A=?d0QHn z(=ibW60Qhw#Mx#w+IY8OkV4$&#xuX+sryyDR`GJyDF^NINNmpvg%pC_7O?ZXP()i} z&B$$aZ{7Pa7P5~qiaaM^h6 zF?=)upjW)sxdA7=_X|de25nR&UdOB52j67y|e8eG+61&Dv2YjS6iVpFCWe69(Q~52-DY_Iz z7#x07wNuGFOce4sH_Kz_5^X4>{yajXz}?yE6Pd_EI(A$cepO57``P!-Rj9i>sBj7u zX1{z&ZCXNWNB56nD?4pu4v322znH#c-8MDWJnD?GjT)s>?q#tqg8XsDIdPKsBm^N_ z)BBiWUM+a2-fR{(%0w=SKR7#jCNi<_&8T(fzimrN{<$q>f22d3C`es zZ>bAA+fEXzv8P$F`Z9Zq-oT3{h-_O zV{Iw*B_|Z& zG6wFK-rr3q=~njdK-j-BRdK3NJ;|JsI8~@l#2K;>M7%K2`ooIWuBjwv?4-!l@MgN&%#k68nXABrI`p!{TOU_klF=!5~~Wx9_h z*r**xDIj^_){T`e|3E=(rF)5R;@r?4if=3di&kq;SA83k4@Bbx5Y3Z-P__vh)5l~T zn1qy5Y)ogBT!}CUxex zV9%@FN+(KUvapYtYh^l%XXc?#>w)#M}|ofnl*O}g%0=Gy^38!+N*H- za69F6RsBe{B+u6)9h~RUx%QD|xByxH@|{8O?N`&zrK&n(;ipXgmVAqEIL+D`CV@~> zIJ57e^9TZtUjI?fLtkPkc<~K7M#Eh*?u$GyMLa^<3x| ztmadtzr}m6wQ-ouf|U-!zF8H${+xiFMLcgam@muShmSIARttEmnxzqeNPywY-Zzu%=Wnv`s-W8pG1AWhr6r zjp7Wuf>A#$plr{uSy|v35{vMJYd*oH9)K_w8VlRg?34=nyHDpEXovr8C-txcF8gTiUs0dqy6ix7C8DKwlZGnYr~gJ%|V9;DZ8I3mG;*pPEu%vnziyA6k( z&cmU&uQoS$@du|PoS79z;t!tht{55PI-V7W6r{ZHewWL2skd{)lp7?*aQVY##likJ z6DDRj@`hk)%O2(EMW!&?TbS;-JfDY5jOUp>m*;U1t2cIT4+pQqe@))80Kl()8X^Pq zSF2j`TCYHKv@lNh!Tif%1UkT+3}CoFfUn`04Hgv05%z8$XK+w>Z_sHzbTA=(y+}+b zbcK4;l5pGhv2WzI?PZt9ZQErk3*Fj5B%N@dxx|#;?6w`@clOPY&tZeN8WL6HKH^Dh zIEXf$yvZdlwPL-7aC8l%LDgSNLv$B_IPh_<74 zP>z`ugQoMSDc@pN?6QNhSA&w=B1sw5No5(tW0_fJ_7+~)vz$RWGn3?bX3ug4Wu!NG zUQfd53;%U_k?^Va@OZtZ)9d-Ps^%f6{nJ71oH^_{8!e9(-nNuq#I$)mpE|YFSc8v@ zufD<(1BPC$Zpq{FSk2mIA17z|X!*-=0@Q&2Um}G4zS_gR3F$V4XZA+I>O@U`CUT}u zP=dWkSx*g-ct(0-T%P6iM8~N{KEpn*EdxZKQ~Dm4FdWNyhr+3U!-0~6cuQO2_b$bI zrr6nD!AR$~y_Z7>6(pLSwjd6ecm0C5cD(P3aUR4&GkZ2!M#w^1@#C`E$Zd0{cRuT# zIA%uiN+yvN8>n&g38_YLmf^}ms^(|5{d+cPZ<`mQsQysHYiA_}|QIhF1OmqfoWPm}njp7%@ zuxVy#x>mydZnqCnQ-0qV-^Jmb+E~Qp?t`|ya7tzyT0AQ5nijWr2wjC2Fo~Fqh7-Lo!@~Pb+o5pbc9QzvNLWH915|ui84B;u%`dd+vD&>>tq$5- zy?Lx58h5KG-!Q^_*63_|Zg*;GGB^u(u|f zYQ*aL1k026Pi)r{Q^&vWP_b7m94E4vWx;S^4|uFHulT4;cb-_2?7g6;fPRA;n8}-V!o8hGH3f0pbLX?@?RpWmTMI&%(ix!gwHgJ;fdy$098_{M*w>fzt>C-5Ky z6t>A)F$0C$J~Bj1;{$ViPw?zJ*~7L0NpM!2`D)3&N?f(v)~}ZlUbo}O@NR)9TQJ^Y zfm@uNhhof;-ej3i!gc(!Mj5 ztyWHI|1)rGB-@m>1ldN&MvVlQ8_U-5H8N57qo)>rADvInFXqsLb&AY2lJnTgHDXF!S5p`5jg!$2#tzfJa>P2L8un%pScohN`Pj;$!ykTn&dtR8m{ioipP1 z4pix><5l)cVqMSAcizbFJjYGms zj%>x^*TW7)#Y`^jQVWd~whq8ibd#hxkDcPDtwK_MyV-fUdHs&#V^Ug7^3Lk`y*mWN zI=h=+Wk$v#cT!bCz@iN${Z{T{Hv&h$Eu486EYJdF`J3r)>OUNnM76)9KX)_ajysOO z;Yab>yg9rZZejY#)I_e5{_sHf*(sVwlk&im@WR>`AkX@d37Hl=IS7Tcr^2~io6L(i;TH9uit%@|Smcz(r)brmYZk4GA{5c8dh6LIil_ofIIo4!PeIr@`ldBy!@K0LQ^z&9Kz%%oTFuoKG|D$To z8EEWQ@*T(77PaRhwV|YKyFKJACX=>73p%gnTfw}=RHxo)%PHc0LlV;{pOW!=WdkZU z`)D%7K*u`YhfQD4BVA{i^TJPu4^}prU$01y^sET2`(v2RB<1ROX43XmLC3e;)>I*1 z5{z$Ypz=a`^V-Rqh<|OqBy@GxdWflK+S%h^SJD|Q^LOhRGp@&S!4LmW44KAfIsW7# z#Wx`!)xudrky4f$ya76?+E@ZP4Q5-k_+DgNqsK@TDrHej>k&-?0aBj?M+w#|UNVhE z)Kf65Q;rr(zDE(g5o+x|IJAnpytXZIIVso>v8G?jZgAGb)qoVH2RhYu%>1&xt`TPe<@qp{t@J>LhtmZ)bmTwLb7l>QEZp#hh`MW! z-}2x1$7N|^itW#SvPX|U6W*ihYgjkV)Q8@$t4vR#GAMj-4#QC(<3qZ=J-(@kQE&!} z{JEw%qIez8SbVV=XXQL(InbZ&|K0QrKMz48;1w`IeyrjWoIpUZx)QZ`i=q^(JDh;) z4Tt+4Qrjg&Qpe(5vZs4Dj!FH;58iS7Psa}uvw#>6e{!uOUk&!$j=gkIWD*m>L@ViJ zB+>B$0A;6Z55#rJw0KGhKmRU5}Yo=8g0->t1B< z2xL>E8E$_veFgG zFq=(QR*H6h289S60L`8~2gJssNM26oNa(u%G4oYv2Pd>Cat@$Y^qwoGS{;9|@WSvb zeC_xHTkXxGJ^6^6W9(H>==#U3Aa*$7)E>cde~kDo9p7b$PO{Y>nSgIif%&-GdBSud zrjD9VMcoz0to)_zu-Xxncxj8ZBLp+)T!P?$&<3zGkZ!tPy{-)CR-EWfR3aHJj6aw> z8~?R}N(h2xpWHN()&0P3*!(C2t*P%NCPGJy`T4JR^H<+^8yJZxVbFtvMOOsK)y zKRVjEip?y;*A<=w`4eV3+lsP;M{Y+BHWXVi(*N73NW23G#Bi~;!*n{uKy;4wp0_Yl zcp*#1u}_;qr_wnbN97HjTNQ2wG1nimTU-0scR=tv+HpJkNL9{n;@r5YX4ubZEJIax zYWISQLyXc9Mk&7Ok_j;^unC-u3+U*I0yEP^=p-%>BL5YP)`%Ug147Orx4}xAwTCQn ztZakyJFg6CGtGNtN}x}dXfJPWdH?h37)T+8&j~ZPLXSe2nL8^?m>p}qIp8)N)E!aR zabc)gG1?ntppRu@rx|Fua7+Bb*tvGVeMER5f^SgfWB%BWRQd@=lu+$FANLb`&Zryn ztG)gQP`ywmEla>1cB{b4As;Wo-XQ`7#W#KQ&+u{|nx~y!ITAT!XV|X5N>w{3bTH8O zxea~v*`nim@$Ke5(aJ9Gmd{#SpD5x)rg660{D2`R`)XTtuNA0x#MB;0*B**z&a}lI zF*CvqpaY?Qt7fS%<=nu@3oek`-$Ox)ZWU+ykanzT1`eQ2NBxuY`A?L^^#4 zHQ3P3!W^#;gYgF=^b8{mAq>t&CDe2*u{zwol~8H;$?%Sq;e-5f&t)j}q?x{g?OGZ* zD8SpiG49lUiky4Y*!5dh!k<>+4O4r-seJ${J&UyD z+{Pv7oKEe15H&l!4f`xnyJXLCA4Uy-_C>}XI515u;U}FPk(pyITSzUlIn*>@Vky5i z9a)a}{5`$4z2kR&a2xCA(QNLwjI}P|N6a%zlkS#{0%87gXE<;5jMn$fZM}SW3tx1? z#Y*Y1=aAC136AJ|?XP%New!+Z{efRw|80bMvVr=#GN-FB#KoKg-h+g%cDl+#ZA*C} zw)9xGfdYFE%l_>yU1Be;SHAaXLHI&Trfzol1w!2YoL*tUor=?C>Kg9-WtC7j{>UK< z|JbrDHu97A*Cy#(b_dcP8}MT-1b#Hj$>^iR8b&PUhC;iZmmNNO*KhR``#wMZ8RFS) zJ;CYPBS9>NkE+L&1v2*gZuuM5UZv$eNdB0gYy|-S@Zx}XrUK#)c-sjc>a1O!Z;?=I zhtQ7`YWI2lBPr&x0?T_wwKsnPT7?FfX`PE@sLp4rn&4j_jX&6ur+t0yk?emnzyJ4B zF&7dI>cN)${x`$nSHn-O9Lry6E?EiF46huUfkLnFS-Zy|Fzwsg8aw_qM?g9|$?e6@ z&Lo^m`iZV{O-o_=IZnd27lgWWcKkV($D;HT>;5A+$2}?U*%(d9J2}@2elA<5Gq@Ep zH0v#CRTfA}k#sUc(upJnLda?VQW}#)Ypk9~qcKvg<0j4maycaRE0Tv}axv>_wW1ml zUMBK&illH8i>>=KTbbHQO(8xYey8!jT=xmyiws9*`VUVH@8YE(+~@xiEb07}=3`EO z{z`n+PNNY4<0i5NM6c@nU5$!&^;aYF5LAHbyS|6m7L$6_)kf=f>oybHOiQJ5QtP-X zXuZ_7UTj;hq`~61YrSxy^_WEftv5#e=8yQz_sygE(i5t`^DdfCN<{Daf?Bfmf5xIg zQkDgz%%Y)|M$7)9MujdKT^l1399r!-nV-e~z>*r@fD&CLNB6+(k#i0R?S%)#)p{N;ni zOW{iAV>nVl8S>F{s}tGtYn=W{rF9)qFDv{8w`r(z&Fz#1c4~98g5E8#-luQV+bk|67(Pr$%c1h zN-;Z*|G_*FCglmpKl}{r^D@nzLObf?#6R1DxHKTY*_QllSJ(XwO;x_#pqyoamK$ba zC6fR|{LvrtJ%V|*5AzS{5vVS7=M_4GicRO=>xEs@yyUy1q}z}c6&}~@4EMpJIJ3<4 z*Q4Hjm~(KWvd{bM9(#P_K4p8Z|F=`PGgq^oIL`GkcYaK6#Z5^Qbx$K~08xHTeS+X| zIUKRa+S1L(I`e1l)^ati_1w9w zr5x~YjD!<`fr2Sk?Vg?eAl~5N#_0IRST*eux1uo_Zk))P4P5z?1Mbj zsoR^TYh@y4YEJ%#e_C4xL*rUy2+?kw>oKq}b8u<@7TLdwoN{>tm-VQ*JerC0@Dwwb z$M{K@%M<)0&1yMKmWu7fzh;C#Ws#jhMgVb{#JbP&UTi9S9ycn|Le6+yzv-7dYF2VU zYABz(t~qXYah_(xaR2YZETcq($Ah>~8f3on^L+oc$oye)YN|T@a_6I>i$vEQRnSGL zH3-FTX;atf(i5+l{xBru8#W-8J9`A=*|^+BdLozD#3DbD(Vp}%<$s(n3l%xf%o!J? zq2Oy_o@vGlq$Oh4=l(%E%c_g)DtzAT_XtXHYRRRw?{ ze-_0r`;zV5SFOdGxd?MUD^2F=XJ{v}z{zA#Lx`O$rz9ELk zY(5XFXpW%{>Fc4)ZK`yrmUts$>(B|@=0VeAakxmfh=yHevwb5z#uJFDX1#rru}P}e zL8v{R`HbY~hJC08=cZSjz>+vng20Q^%t71|wik90_c2?MUNM4jVn5`PPWVahn)zgU z#Sv!iL~c%?st%Pzv6Iq~UNPEvfxeEGtT>v9RGJYYg=ZpH5ZX|@EBsh?c6!CpE}P|O z$%@gp%<}H^io@&Twt_2i#ZI@GbFWDCerqwmwHPA4TA~@+_IL|gt4pu&{MPhwB8v(H zS>BsoacCU}?oKMlS?H45iA<(;&`qQp4s?dmVcC;)Y6r3Dk6ZICf;W8^Lb3k7wFfiZ z8ZT`eHAmAcj&&9qFmqttwB8j5tMI*44RXaiNLt4c)9*6}fByygfe<0^@z}EXhOUE% zG8rWd<%tCFG9JU77H8Z}#V$wV!BY-hW6r3i5o*`2Jk%4RT~Dc<%<~0 z!C>lIQ9qM8%4gI>=5T-KiTr+|P4;(2^G(|c?Z(wc`~PD~|L>>3Jo^t%LCauVF?}HH zH;*iqPx@1yCrW4@$z)Xj;>Jw3t?;Qv-(!6SAN#MN-fO7$nrObCO=F60G)qdDZ7#S+ zv+UA2`PvN)gHA9yQ{&_>mfW$(79n^N3c$xYSVDks<4WDG`@h^zDNrhpCIakZ(zm^g646)64o%hw73oT*;MO0 z(|nIjE!O?#r1skB!2J0B#2cZrYVR6wsJ4%;z{nqAD&yh;a3h)6T+>+O z^druNVcz>>aKt{9%D$W2P<4phcBZIjMV6tD3{|I;qA|d9Bdc63!JrRdSYxrERTjY7 z2i(V;&IdyHHoX?VxySN@eWvyi3>a1Xuo8q{kN<2*6+R92;TdA$EM zoq|QUS|%SmGQe_vnpfYWPzDX(?@i{JhPz5$R|7nKtK?!Rfd~!qo3CM-%Jii!k@UzXx@#oCz$A9h4`jImbsjPNJ6CJ~u!VS)7S?5J4Bd;HS zj>NN-Mi!2tu>+Fz<2Hv0zg5=pESasJ-a7WAPRZ{3?|Fcxm`A?7y(!`P!bnrnTY?pX z5SpS@Z3j+@Rkp}{$7=e7Zf1|5YdP^IhU%8fK@b1W^Kg8rKO)DM=#gXku{8{Tk5sa1 zm$xRe;3aD_s)?*0u^FTP$#(8`YgQV|L%NxYgr-eW%r9!5(Z<@dVJxt|D0Q;+#irW2 zKViCB!eg0P>zpA1h7{>A{7&-=U+VLXVmRUa(hy7NvBffBallm9>VBSqWimFUoVA6a z)_1d?f^0uxraq*wYu;UCl?}=nE9%HHIp-Jp_B5Xp2ispD$hSG!eVlEjK%E;_q*~V+ z-3Zt=HAYX7XA54%v#74fN^yBSoePh80` zOOF^o{KE57Op5UC;P@J&;I>qlrWCp{igWm7_bap5;d2hs5mcsFb`_dM3_le89RED} z#>2KcS)T?_UHnRQsH+`S2$jvR`JK{7f+}~IMHMa)n#qhFOjesuZm9h_gC6-&9U4(= zNqSAHV+)&M{#>y-;30K@|2L~MV8*Z0xB&#J&fJuPR4r!kielT;cajm@t+Y7~yRzS@ zvTU5gG1Ud>jFlB~i_+U0rgE0Jw|14)`vix)i_Dv}+<}JIVc!d~DV_>A++A2{KH+xi zw0RLf^r1-mdxiQ_5XsztD)@SOsN+e_X?&FP<=3(+eD7=F(XrM?Lzx@iTtO;awsbqs z_E8y>W?m%j=7v1mzcE~7M@wE` z;g&u;@o9VT2`mU*EJR?zd@*D*jekknFWW0^m-&;3fPjB~%f550jJ_94>iY=XWD*sL zhALk%F^Sn7&dwdANv>^xSU=( zBU3d-EPtJpV57aBd=XP=-|&*I;A_+rZss)U5_2LuJu@q6K1kOp&6{>yUwq3h$mfY^ zV7owkpg-i9+eQAXxhv=6*;?OK+PRVVL+^sgkG{c$Y`i7zbK$ZX|^QtJjtu}x>9{AH@B#FbKUv%re;C<=1N}dLiUeR zGHWC+69KHAc1|opSESA8V)cC-X4~F)TdQX}YZv6%3RW>(&YDUDLbs{RZ>5Uy@v(`j z;?@umd$v~klkkLJA_^0&2#@A=i`=G2;3Q;6&g^UsoEu=qY=dlTq>iz7a%J9jjpop_ z0tkW#EOEQ`+wr%{y18YLWSz!q{jjrLz0SwEO%i}zEB!n>y}PglnQtnYKw?arD27Rk zBh4qMjv4hGG2_gfs2R=vt*MC}{{riUtq^9a+vZpw>>{KUAi9VUfy7(oE{oI{N-y@c zh>j!=h?%A9QXSi!!I+%|`0+Yh>uER7kLKGoeW<#SS6#%_qj8y=?zxrM>&`Ii7x0S1 zqg!2=jhP<%R#nfN4L&q4i8Bm0^thXq-Q%AT&G>9wGOEN#GW zpIiaiQp4XCz+y-?u8Un}VdIJTSM6>vl_>AmuU4)~;%QIw+UD{|W3=JyC^9{dkc4@S zV@+~Ci;^GfIiYLq3vA7ummJ@W%Gn)=Ri7TB_xud;tp+*wRQY2z}gETWbK`iJnb z;Oj+Z|Jah$tnk`Yo$_@MPPE*bWo@&0_=Le+Rir3AzoO$CycDu>Q~(})U$g|03*%p# z0tt|2qmigf@tdvMO&bhyW0E8p?irjyb{$gjuPv5(l1z==r158n$2O=7MEUVimA*-1 z%xznE;LL?j_@VU9w2eMM3MX;5YTh}6v#glI(xBMM_<`-pEmNG1D)z}7RBNe{^Ihh4 z4OX_=gk1&(WE7YiW6LUQJWGH}KV%>Y+ex^nJ%YJNh{F$s|U@V>j91?zMm6Rh9?&gT4e?*4qzy zMNYPL1`mwKsk!eSS{Lk_MLY9ASOiA{y<3V=&}SXp-lSY~nuK2257Rxj^S9%vKmSGm zgCL&(O!tUXulrZTmm%toWtP@6h~|z!Y)g0iWe>S8OQ&NRu7^!mAb3Iap|?#1f&SDn*OX(ec~}+xcyK58S~B zPs>Hd^rvvCKZX7Id(5SK{C~Sf)6N-@sPoVvFr;78_;2!a7N!G!B7UUp%K^*WbQh(tA3Yxp@1U#=QCMX+0W(Wwp*0om->S~&5OaYJ z*}LWW?z}do>$hBeSpyQIcAZ|Hif{TtFln5@m{8KRbi<$r9sxMmz#Hdh{;DWC*Qyxf zW{iMRMa$_P(RJI$_~tycS*^BBvoH~qbGN%GrBtEBF5Y^ulpXdH(obA}sZBg-()`V| ziAgijM90}`wpTfw8|x zRk8)@`m0kB7JrUP+nN?+CH+^L>LU9yPcz~r&9(` zg^~{y)F75oZ1zA8mi_X9nOhXk#0c18ZuLLPC#Doc*At7EA3UXIP*o|V%Lw8dWSVz^ zTxBFL(7AW&kYhn1IguTJsGOWZ8`!*OBlQqoFa9%C-Oj&O{6w8$vzUNZjG3t%moTT`M{OZsZTTf@#Q z50)vend!sPyI$1-ix0zQ`|86%ZRPQwZLnW9rUV5=8rdQ5em1^QPG>8fM^bn48;W-e zD)V^Brqp`9B9$+fdq8Y=_wEi3YBG#VQdhEAi&6BOJ$D>`t^3(7f>&5Jwg36_j*gG# zVqzSw&z@3(-Ls&?J13WzF;U_;mfejO6d%HiPgw8U0rMRiI8P z@t1-sn0!!^lgHh1K7ZW952V&B(`>NXSHk9WtMK`10OVB^zUr?6a#D%E6i7isI~9uo zqOviwDRr0s!7^GTkOd^RGKX83b(Sw+a_lf0Q|rmb^zMM$Okx0V6w4Jh*^e8T+{(vq zS@2t~Up0j_50*Vk^2<1PxcPbQl=_K2ORpfk(Aj9YUW9x)s8ST)bc`cgq!h49S5BA) z3*ukjTFXh|&4xkk3TWFx@{N2+#%&8N*0#_JpuRha`%}q0-Omn9 zz4lER-lHA-xOFY@jUqSXI@ZkZYE8}5iQ`4HS8(elD2q5hJH*!zSHvTiv$nv_xH}|j zxL~00ZwUuQHfGIfgc@IE9bSQvu#cnF2@&PXImbxN5G4P+P-3HI97%^3}ubIC~j$4%4IRJ z>}BR=8C`t;t?Yb7aA)_|za57)!0u2`&jISme(3E|+Y_XoT1rO10xtcuV`uGa#66O6 z&EML#h9kvQD8o!A4~O}QbU)!9`YG4I26hs&Ol(o6;n*U=McCc%`vj=$c(uo{a>cY= zJcFTu2m2dZ;f90|SsP=wI*+L4L5PP*XLrYKd%~8pmMeJP30i!l=sb5)cv&XA5Ob7+ z44Ik&(~RdHfXI;8lvr%GT5QQpW7OKzxU2Hmb;TvM$K*_~Q_ckP0=RE44QLyqiD2gz zWPlpUOVAoOQ(hm<$G_Cx$aY*^ ztGDZKG^d2lnY)AYc+%w(lqYUiO~N*$3=3Q0_bzO=U5+v)_RtVEIPfIDJZncn`sRPD z&M}kaWt^}IoK+qW<-V@@PD+#sUo`wDdd>93jFPHvjn}tc$XQ%2F!Ca;|08=NqGn># z2dq_%nylZuK7H%`e3HN#%eLy>doS;OR2R!$ZQv;L>gTpjncJGoN^VX(a3OP@G#cV2 zbA4$!-~S>zDv}A%D#%!wrk0*L@cJ$Tpm|t1Q4+-CqiA7neL;{6yhZTZ1e?$#DZpWT zI$rY$yfmloVo zL+j*9B!J;6DzUU8RjXZA5=Biy!b4~#4T=am_3Jbwz%>jKqow zai-jGm$^*CKm#A`y3j7b3c%|aQ7qWf>gwdLzo;5Qox|A$(*s;(Ho64`^*ijvGVttK zooSW1iTLzItloIZV)i?OGtoaYcOeKuoOF$;3b%Ao(Hf<#mje@!&HV<(5jtVz??qY> z?mw~;sOiZec(%X8X%B%fL7_?PfVikDS5A~>+HRo(Oyu;XFOZg*w9Twxf_c(~n^jQ1 z9WXCl54m#}qo%bSDc(b}mow&ajMf<0pSwIa>B2R8{FwdO4I(@=Cn03B zhXO3JAqpfo^U&p0izyM2DJt+fgS+&j>Fj=lXl*XAHN=CmoX1!YroWLvcJ%P;p23)C zEn6cn7|1!w5koRpPv#mLrw+R!t8+!o3q|jw<%v+U2IzAd5&FRfbkq&3moU-2%kWTq z^se*UMpuBwTV81lwgzLpoG?;}OMhse3Bl%;lcaU6~t?h|okdhvT5l>HJ zFUtxxwQ2BBpj)}Y>lsD>?Oy0LJ?M%ukx5a+mXKqX?AA$|G}gUmng4jvaZE>yu4o-u z!vCVC8s1N|h=ia%@-{+3N-qJa3V~SB@<$qD%-R}WHv1%v=npC{Z?8CH=j$VwbQ<<=! zE!j@_p`gm~x_Wr!5Bnv+2HDN9;^k_S>95%?ccfO(Q$)eIl50D^0?kLH5)l`@#Q!R* z9+@Lz1i1H(cizr!N#FG`Q2u@rUek8tDN_1hE8TG-yH%QXmlO}mf{Be^slf14ccl|~ zbNs)x$%^+xB6`6tv5h6aQFpif#EM3t4OO<*tVG~0e`m3AO2J#a?vPtDzL*`&J%W&#k^Mt{%#@xf zh9bE5hpq|Sg^ER|zXs*F;fRkRGS)h-*c3`J2>2B%yL;sB?WzMYKd(k`Mo)HsjWRvj z(32frE29`r`96f8PP)woB+Czm*X@V()<39&=YBYG$YCR+S;TXCqTF{wY z8?6-Usk1n+Rw10X$k&UrbpnGfN3B*ZY#cAzJ-N-q<%na1L9$lj6xs8G!!{UV(!{vg zD*Q+}31ga4dl1DZ{&7j~ZItM8Nq9}ckzP-p#7(->LIZDmtp8hziCAx4A z8fPW<(qlU-_HI1SBNBqW-NYB&UJ$9v6(_}fU8}EZOR#sVn)2`dS9G;jS7=gvnC&Zs z-yvt^`0Tqdl(Dz^f=XZS*GNcs$@zrWDATj(W6+GcN$8L$d$jIyn{k}Ui0O^Jfn0Co zOyg2>h-xQ4mhs7m7I@1mb$>@ND)z}Mbp?F>5iRpRY9DUR_C7-@)OmMU6%aM38dKLb`0!=2on9s-u8(1jSH4}6dk~nNO-Mowwzsg z=1LWO)x7I*B3N$QAtQWNFE#O9#pN^+Aw|<2?wo4FPOiJxu#@YS^I+(2=MnSO-OQuf zS9c?i#dx0L0Y|&~b&N`6cVXHr&|UMSJM&4@QTVCKH@`9SyI8-jYB7O_GlBL@poakD zMz6zczwYZA*#o_Wz|DPK=R5+H*md*X?wWnw3fxS9!XsVN z^Sf&fy&jv`HGOe+P4e|vbywTNrn-Z#$Ch=q^_Xx^clp7t@?>|-GYZ^HU{81Xp|0|t z?wVZ++)SXoyL?wy`7_-$B;M6^^E0+FrjdKP%G3_XG3e?3wrQY-;b8X-`DPdnc7MBF ztu8;TCf^WKfF^(YVH4TcReq@Z+f82h=0n{#EM^|Co@D7Z&Mg*1+`TBpqK7>5aja#O zM%+*M>w;>ozw4%mI#n9%D$Ui%6Syh&zdQ2XrO~d^kj9h1O$7FImj=2@^E93WZX(eB ze>tB2#gR-NsbSHy2awDCa2lymcm5`aWh`5JnJZy$L%O(?)d+wm zT9m%Ce3wwpQs>@?K_d5ZAp#QNh$SR)FPH_ab1#_XY93&g5*}cdBDn7urh-HXKQ>BM zJ@ez0v3TX;c&p$w-ukflZ8yI?{2C?w_CW7Fw8mytzL|aD?bGvR;7S4s7;4-;J!akv zK7u|aVzG@dMWNFHrG^oMx{U-|RkgD!0 ztm%r^98BbmE_?~Y5VpXGtuG(ah2kgj<~F<--hO8_jj)wH@h~k8Z@-?S_xE}T#%m5F z@;*_B#CVS%Ql_D&u;Bnbk2ma1OdVDDLc9TUe|v9zPIdc#d+Yl*{TasIi5QXW?(-8{17(5;obw7`pw1-SLeND{AIJKh{FbG!QN%T)EgA z{q)RTPQxx=c-?3w-cG;hZiLiBT;gES0DA{x{quw7esZ4i>pRO?0pqMv*O+xB@+Mn1 zRqE4qfA6f|CI_9|9mjH-e`i)>&7QW?d0ExwHI$P=wQPAP`>teP(f~b06Sv z6%UZb6dn_Ob)Vo-?W_A353mIH-{wX=yd8%N2g8qz;Yb`u>LWj19g9~l?!AFh>^HYg zpTpa$^5JuV1HcHZLPg%+uExmVNT2)8j^D9TIIQ#Y#^^+dV2=MKt@~3)ew^o~CS z3Xfnez<&fI0WV?ku<+%09YzL@hPTgMW?Jyo9+ie_;r6+l;VAyA51R<;L-0=#vlnwH zI2f;)4Y)Pm6FQcSo8tA80!wO%b zb&5OezH_A8M3`pZTGzMp5ZY6}3;18UweHX_@+gE3B;8XqKQWoc2mMD9lkZmKN&h>| zyTwr2aViv_$a~?S_hk@lNBz&Esip+SLZDtE3I|8ToDNQ;2X#VD&pg1qvE)B%mb|7@ zOCAL{v*giT>vBH{yev)Ct@#r|=#*gxtTWjoG zyr8vs!eC;sc2G$9b6|R!TyxUj4Sx>{)jLj{JAeW%;e%Fb&*|S-tFy2q46mWbOp`Jm zJJ%vft;$)j5|}SEahSuwAGKCLhziyfASYodDv4?v2e(QUGO5#6c`*rM}-+NdQ`#*IN!2O<* zY`<<|__5C|zIA`auURQxRD`H}ZIJ##ZGDWk*(mwUP>Yos0kBV;quuXh;h^`0=$!%A z7?f`hz>f;AivrDX;OIPPf}4DB#R&gQ3(LSS8yE1)mX(3uTY)FE`EcKu1lE|dnoO&-aIyJqC8xri<6)PpCN%g+rr*;4)V5} z|FKBc?pS_KNz6GOssEFa*>$62jF*l#*A5%RjEK9r{O)%0_|4kwTx=hg@bE3|bn^A8 zfHZuwbpCe=2&sDVjMu|@674K8w*}Vsr&MOT;9Ug7XXXxys|3!?Ar9vuZU4GIXi3K% z-B%J9h;Qg2RCgKNchtQxRPG65eMCnDUS#t47iAwpM9R6 zI6bu;DR(bc%XS{?(aKm;`>ieJgI$V+wf^%ihu#QFWPwsNX*#d#~C+9eD}9I?Zb-t z>PExH3uM&~*CWuF>5c&>=_3mJ7%yx93tUs2wWizsNNU&V$@_bP7Ki(UKos2xAfxE~+Dl{3?s+mq{I=;NvJ<+< zW@5z}mz}%{Ba#8s#TVpSIHDi`X;xH#geoO~B>aC1B@F=~G(TXG20*m1TcJVD1%}Sn z*|0r32hy>fp&-Y0lqUc$Tf&y zf(C>n$a10a9hMa+D0L_&o# z{rl$(myfi;L|MT&o{_Uvap~z*Xr|k6)Lz=Qr!_l^X#qz?X5pVF(zu-#kHMTzJ9px3 z^C%N}h_)F87XqLr;vy!;#IUg-wo8(WmIf{$h@82>>PH0w@)u~|8SISC^41V*_4qdp~3 z(c@a2lip&;B=s8QVkFpb<=F=A4@x^^UMVfwc5Z8=w45O`IqRjk6}&uD@IEUuQhUC0 zI}bE91DHJWzuo-oF3RA_Vj$v4B82389;qQUfzw_t{3m~eUq zOYZ~*;7xv#em+Y%eg!_PbaJwpe&340GTU4&D z?A24v*_wIv>CL=GSHhgFG9;Y_q<`DF=*-k2ce^T5g=Z`L5RDu%2BvVS14TLNvj;7W z=gl@(TxzJGEf!vTjR=o&pR?kY?D{)Eo{;KF3U7(X_T2E(=f)%9r>nAAiQ%VlGgBSp zZ5XSNH%3t3MzR8VgW@51)o86gGm15|$FA>Z&54HHDiGvkXKJqh9+O&ZhbllYCYTJb z%LgMH=#1Dh3~-uhpjGm1&HN4!L>8M{ddS&zlq*rJXJ6{x9bny_$4K_mEkD=L=)-A9 zdq|>x85N|PuxJ%=A+ogD&mBF#HCPw~_8|>GRp=&tlZ@_2d$j>Gj&73o9FL#IO2+E?nTg5-9 zSYQN?m2LN{Z~@A0d)6Ihw-%d38;6$wn0rw57_c*iTm1i^S_JeNmD_76-7aHWT3cyo zWa&AzAMUUIdR1@W(TkIpjI=rt>x|uvpQt@ap%-fuRj55zbi1BfbLn zWu~#czv7h<9~NFEtZhd8#|oGc|Go)jFATSQ!-V{V5+HCk7IB}N?)85m+_K7q z0yo#y%Vb$wNlx4JVL*#taZPSDOF-WSkm5gYcKGMV>h7x}2&Qab$>ZA@* zM@9c)Eg92{IJOoEJcAl+KP-==(=aMDOYZJg!>K?l(`tl~dKU38nk?ll@~B_hM|+vm z??`}|^>Bui2nUeH6bc?#w;rXZr9Cv6Q36!~7Hw#GYrD@Dnj2j&Uyh;Cv?O(bB7BX~ zmXZEWC^gIqYubZu0znKGeo#`9%O`?jhF0>Z`e-U?^S74!Wc@!_u1yU2iqM^VL5_h! zoicdR2Y3C$w7vPw9&*(VcitRbdtqv#(#(chkS_#P6-fRY!tn?P609B)|7S>q)TJ(b zoot4&OjQ$ZQ<($Oo^jzO+of~VB~@FQo1PsJ*8p|h{6TaBf;4eHt6}=8O~$D71l(qA zt#LX-9IoI{D->}dvCyEzJ#;jR!b@5h2)BHaoGtt7{szKanvny9##&1^NJl&>tt<$Q zDvxiopTZ(%$#UK4S*ifWVW8$n1#=hC+(mrhwT4qb*Nvy%&zz#Eb+)h57cQx7^Pe4uh_D1ChJzOlg%isz9C6%)yYGGE)jR46I4y36;K%D+Eg>B6m+13(myutWA zL472igP+b0QaB4zM!YiO_VON3miT&&8)r}E6tRNlAMwUFbCO9Re8y;o+~bqpN?l@d zZ1TP%+bT5z>23$zTO4fuLeij5!W{;K9mnAxg~m54OWnuM80<@Fs?sTs8SK;u z#u|_;ubO5`Lucylw-mbbM`jjlr@PWloJc;&>(gcRy;<+5zG`qyFx%bfMv(Q9zY!!U zmB_uttO!iA7Sd+gEh2^uH*SDNSq(@w_x4aUVBR~rHa9haoRMl0M%;fV7)ZW&6kx8P z$%w=c#9k=SpQzSIocRU{=r2zoPJMoIKq1o{GKYp}o>*y>-;lCN&h8Ohe1C0T7ZqjW)k6;4TRwyC4{b0SokuV!HoU3k@gN_`WC zs#Q4x2Yqs9vv6|bx8%t)HZ3*tmT55VP{6}W&`pGMARP4SWIR2AKw1-*p>Zv_ z7f+b>O^V+a$WVSrS9dv{3+V}#*I_PC;Ljyx!v{9Sd6U{vVc}g=H1C+k(z{{%HXr{5 zbvCSQKK`tp#m&ce@?3dYc(q8W>EYG0L5a;fiz&%@GdsMhkFULVDDF*eLww=YA|Oeo z_0TJa#mzg5l=k@W@K-8$O&5Iq!IDbf_R^t$Yk2>@7k61%rLXz;epNd!yt;*gns-hz zWt2ksSBtpeYnwOBmVAq^8ueKYG{3HTTCE_O$D&4)@8nhh;jk zBmFDj?DJkZ9#)u>M;shKwLw(dB1#z4OFJZ5mZ|Zyu?x*R(qBA~-Vhx2t|BuktXorW z?{R9ST=@(bSPo%|`MBw79it$KH;7<5t|IqRcah0jS7;jZ1=ASs`xY*r3`t|j$;=3{ zFJ;PLFPIZe&yLbUTeM}bS4Z)EG8|5$nHk$2X+O+&-^4-0LmDE`4}HH!6)Y4w@=g!U zC)$Z>7`|Pzl)9z)gj!f1Y(DX8o{ht|t3|2ViSjI`XLycjeOGNHF+ZE?ns=J_*Xq1f zg^BX?&{U^}rZQFJY^O0CW@yak38*nE^0ovNXU{X&)Q-BQ_JV6_|F(BAi*eE`rb}_N zxj+Q&PQHo;r0sqxV!PI>>ra!+qw(y-GfAyNa(b@!o*D^;wL}umB^>NPzl2tadXb)_ zHlWR-ZCOI#X!Hxu#mpRn)X&Au4%3;vwxZIPD9P_E3G@}Co>UU_mFtoB$W^FuO<&CM z(x>30{qcom#ay;J$0GHII!p4W7Ae_6Jt!}EJuSXIGfx}M^uv<9Yoha~Xwf?j+3rg% z&((f>+mEISL-o*}x{z~h^zz}G4dwo~&By20Nf17qz&<`ZS4cn*KGzoG zn#R`UVBfL7pfO%SBPc-yomqhLqbSvtC>w{dwPWh|T-XJB5~XSX9{Jfi;qEBhX~u)I zp7GDwg~o&Af3OdXIaTc6y{2^W58EC$+{|gRisHEJ-eW)W&g@|j4df- z)T4VC37}++2t$T~m?gvz(we`I?6}oH4KzIm`wXP3!n1AE^kwem)yn#c0VMF{`X*jA z7MpVghXe6qt|(q>R?1NkR>O^+7d|xn&c^`QeYx?X&eDKB(LtM5gj{J9%_$<$HJO_` zC;1;Zcye|{KBFjDs#YEK!&IwzbgOdhY8vI0q&^tk;Lqi5Q;x#ru&VC*hzecc75IQH zu&A$}K|4@dbawKqe7+77TVcZ=HlI3Gm2D%(^=qY#>AqVx2D_Yjb~G?)gqwDnp4%A< zmR-%lh=rD!M`RO^__C;STUoQ&I`Ye+opWDwiTf^g9)!Z9>d@S%=oPa|wY*=S18?#|?P3IR#IL=~$E3N|uph&Hf()OR_8O15y0jt{$S%(d?MbCPQ( zniVr?zuEs1)39?~g7YnZH-a0D?>Q&3vcCyjDoklIZ+J$5el%ClYAWMit6 zCAK8@e6S=IiZkPYz7}(L%luEx^ldKVCoy*(P5eAfyk(u@8cp01;$|xDPQ`uR#4RN5 z(~2vZLfj|#NzA>4xDOLY@62AiK=AMZ(BRw`^BH)nWcOn1wSus%*jYMRJut((rAmFl z_mXbhI+AlK87Y?1+OvqT$koDzACWxnKEkgtNbQ(Cg80Wxy!dX;eUpQYBRd_183Qlf zCVk)V48NUDJHOfjtx(J^LUBhEy4%^yFLE$1+lNdGN&ID>UKJ37FH5Zr5YYU()#IJx zId|U(k$d0FO5gMRZQ$=A{{ET2C;8jXpPAWYDVaJ9Ws#gR5d63as=(ymm|%{A7brOC zm1I~?vkQzMr1dOZx4?b(FN}J8`BX;AeUS_-2qQD$oXQD*Whs-8F8Eo&tV&`LEM zo_FyVxP}JvcWpK6-%&1&T4(7LJ+Q%OShY4TX0&oZ68fZjwpZZrv-TN^PE(JUQ?!b5 z;$pGWCuTP2#eDK|R%*k?#R^1}%6Ho5X}g|wX2O9gOmR7yeU({qX3~K&O=|}ABhwnO zoHPB<^wSSL2K9qVXiKL7j-gHNM4ZZG(Xt|^wheXBw5ZdkD*g)@P9G=Dx)}krtn`dB zhPDh3GK>?QpLu4&fzF%a>^M=TSiM8rb$XdOCrP4GwGK~9I#B9gY`7hf;0F$A{{-6< zgCXI6XIM24>PDwe14<{(-V{1vTq;j-OQ+yJnvLq{$i_UgQC&zrckUEG8T;7A3ANeH zaCkQ%5%?Nr^#ZG;hg=$qN6t1z++;roFqag~ol^fxRimwOpcrE8{fq@a%&xO+Af>cx z&O`ttPmU@u%ims5voj>QZf#q25!}PP+V~+a&qC#ivzIo6O2xKs2*y_^N71V*f5XnD zjJA%s3lJM!S;$5C{=~8XC5((;BFCj9#J?z2nuV8V#F11$YV>VB^nZi1Cq0*J2K%Zk zb_{U4XrS3nBfEX$6cD@)3TC^<1s@H!R?O4>y0FtY)n7NFGfh2{GiEOsz3%u!N&&&f zb`W|_YV6ADKBQkK?Tvt_>4OBYDMvZ7HxDDukP_oFvDscZCU&fi^~_GG6-zSd zvTpOXJ+Hn$O4&rk_J8o|d+GEKrsPdxz~9~9xpQo>1D!Kn-kQmpX{w2ptzA=7rl}@& zosAvT)XkZ6nHHIJUnKT=Lm{>Q)%~aC{n`t{p>r&UTNp>)q_W^8wU`YYHl=%D?kmvjFd- z1o8Up8Qv`oLLHy)ZcuG3LANSDj;K5B3PO(?VKL_(WNOjP_1ZQE+s65YMo`rnB7v>` zYcWPU79?QKxsT6au4EY{P>^NCSpx-Tj4WNmnZK9zE_ILp)%IR+miEF_yyJh=<|mSL zaK|6~MgMu1l@AszL8o-=02bZWd1|(?ax2bdFzX48h`ZYy*>x6!zL?a0ZM+nT=Fc+N z<4og1q+#2Wz@WqwlOCYXi=oUrY=9`;zAsaaw#$jIS)L$wF zAT{~NcZ^Nq3Zd#js^LFZxd z4N*#T7h>}(^J3Wtf%@MXU^MVw8g-7|T+0r!wCAR|W4F|5c55p)w9m(p;yh^G7A95sz>tWa(I$_&(k2SoI1)S))-|%5BqB2l- zA<`h8V0}hV)&L9$L6got&jHyuV5ih=kN^y7NAhQe7SK4F?~2=TJc#lT4NGqHQhBfO zfwa0mKOE=Ir4O{|-oB=cTN_I|OeQ0jG5xdy)@b*;&n|7AlJ?zYd6A{k%svsTPdPtt zBC#hHu|*dHup8%534T$BZ*h3X5wTfhyOT9)%C8|A-U#@k1<6xviLz}Vc`M2%)RJ}) zMw&6-7YAwAj^%cK@bmvav*{$ zH6`j{8#f{X_!#W%{EFJ5=JfZ@JJW9w2?Y%Nj^vgj+>!iG!tMssVqlLK5w#*zyGSUy z1p3+Sz@~|_Gnm}Nd-HwyX@F(ri01oXuk`yNzMP`jClq7W;8=I=WJ;(oCFB!YYeMWG z$yJ$Blj8|tXK8sX^-&j0lFZc?d@Xip))$15LGvzDb_%v9-f!j=-8ZFvpSA%rU%>Zk zwo9Xxazmeakw@xb$-F@^$?arE)^qD&5~OCjpQ4H9C;x>=7isJTxtXQ=A!q9p4O|^^ zug=z(g0*39#n%mESH&?E9`3Np-I2VV+~t@~D*CZ%t^cvL!oi2RD%N1 z;+hlwXN8Mxc&5TjY`9qAf3V>z6#jw@U#_qSLh@cbDE;RNo4zc}1g;_AR!wz!{kr$h zu8pL;i~5e_LGF`o=&*8!9m!vrH!CGTD2L6lHG9TeZMsM1Ex|}WB`BkmYp^_ThW(L z%IGcaHl~lEPldMZuy3-jX)n*&Kdc{k4UEo!-o~iyZ>{p&(ZAqs@Tze?Rr`s|3cJ8t zUv*bN`Mij?K_6%GI%xTQR~WiFugGAsTCPizA%P6Y z)fH~TtuRr~^*5e#@Rn}klfOb*#NZP5sF_?OtviSU&)!`IU$=GyZd^N)CyCNwTOz}~ z&i2R2>8tys63tVhQM6IXLu5kZRr~jyYkK&kIunZuDmj{!A%u9|q;#j;U!^%C;jt}N{|>~3 z(OD^~m{R{n%4(55sGJa1A@mCJQ=}UUmB^x5Q@C@5Oi|grKM^~C)fb6Fj~EfK zM(J+_16(7Dxn!7dl3_DkxByu!lL-_`S>#NhEI{E%LIxY=xtF%=ug@vEaS9p{%5Ay} zHP=sHQZ&$TQPJm4YDmtO!nCy0wsb~8u>MiC4z{!ew-_fYaVXS4^lf=K&g4t3vrSz_ zn&f&qMI8}e{om;k!@mj|T&R~t>MtQ88f&0nQvlcNhQm`21PegM-&%%k1(OAX~-@xb;FjtlSE=uA= zc#%`&^E?=y(IQW3F`5W$b-Py1Q_4Ire$m-0PkpGUux>PB&h5U3#A^;dg72u7y3jOKUpGnvkSkj}F2 z!`Kh%(a=8QbwHMd{*th~c@Dk(ehgveC4 zG9L|Dc%=9?ec8=UOb^5zQJPSp7rCE~xo;=xag)d2jz4Dm?~BDhtNm$5peVckcWy~E z?ud|er{~7qsS1?j#hsV}bMoVc22Fh#^c*-FpWLia%U7zJ5_fH#i4BHy9-9a?p}ZTT zWqxb}iIr1SI;FnX@@!NkILc9tSJBk?22~k%Me`2yceb-tWoFfV(REEni)ousi94IN z=^BB1i{i;VeVxTBl7~v<5fg&$ELM3ww>aPZ$Iy}Y-JJ-lWP=ZjE6L}C_@>YC4Z7Ls z4fErgabq`uuM@yZruIOCl+1Zy5L&XGHuxW`F1-B1-wH3A#+l8;L)Ys~v}r1QPE|SS z{e+{=KnV4&Q|mx4Bjx$Gc(Pj@iWg6DXXE*2Z+y0V8x&98(c_O7%fW$r&*URVye@Rc zi_7#i-@Rwb;K)k%o~f?sn7>nZ8wDQg;T+Y&7LYpEHEl?nH1Q{0_1x`rI(6ZGumY$L z6g{CK53jvhr)qO4%5dZ!`LTNT8J*ecxq9b;u|v`sZl_?=eM0ca8Ocdz-8mLBGkmNJ zuYQ+@H7deAvW{6D$-gn=@1uP1)#bDOuU|w)b|*rMO~_E9tMz6TUte^cMm0C#GL%T-e*i{$w#1KX_QfY z^G1El=?ElDC}>(bOnb*wN+|i9m!H#!2~*Q zTV|VoS`kiTzU*vfm^d(=`-7-Y#%F~PC>JnJq*y*_H=mVvbe~F&Ct$6r zgU&YFyUWt0`KdfFGIg#Ojc46b!{Oj-x>Og#oU4p1jeFb-k6;# z<4BfW7t~KkKau$CC|2y3kLWB8Y`mlLES@3Zt)hx1j!C}_cY$f@R*c&Rmt&JRn3$W3 z&2U^FhGyReA608WhG^!W#PYBb)m=>rHkd&i{HU?z^a+f(rh}cOTF<`JhZI+fS!9e6 ztDCZ*TN+B21~Cm^^q^?RJJ-@7&uye+LugY6XU}(0khGH&BN3uOjvCnMTS$L0T+eIZ zo{urWIDr0B9L*A#0)u9PL-S#`!a5fKcU1#&v-0HeMmi1yjtO@ghevD(ulAo2`&wRc zA5xb&IcQ%r#an-gv-0Ud)kMwJqRxehH-Ndnkqk; zxHc^#>@OuJc5}GmL;WAsam#l$^I@)9yJXUz%ulHL-h6)SF#yB)g|j9X?#1FV=A|;NugDx>8YWLlCpdv%R@XZ+psd@65tvz%-MM+mkAQ%u$v&|dS+Bb$OT1#TyI^vW z*36gsL%YlQ{ytEUQzfO^rlPj4u0%%A?CiD{iFxhOgQ~ zaz;1fvcTGi#`ZTdV}lGDZZuGh9MgJDBJ4u!boG8gLypNU+=fQO&SQLlhojN2@y1zd1+8h7{jmg=0_yR>jcTX}0Q%BQ?D%z|DHttVjI~ZeJro1T_4qy3m zwY0o13yExo)sdWpG4X~3|Er+pHQmgA{9I{vsd(h9DT> z$iE!q+c%G(&9q14wcT4`X8^x_iNFnr3b?OUFVJkFOf)C?#L?pRETN9ypT;>bp`7kob zo<4nL5@=+2-PO#Dvny&jt{NBkagf_~^Bur<2vEl8M1RxIk2@N*PT!MXMyPm$Cdzmf zMph)yx{RofXkoNyVZTfZ567&x@dY(&Rh=@HqKn5a^`B@g)&EM* zU3|s=%GtjzxreVAG1*L++IGd4b#}eTSu2nMQ8f*ibk~b2m6ykmj_b|puDs$zV4D(| z-}@7#gOLMZ0%}HsGW?bGM4B6C>9lbgrJ%%mjR#pK_KsH;e3`kjcVKlcb6{1$5aME5 zp5ur;@}(HH$P+6EFF$3BH_ITe_un0GFq=2f z7uC&y8wk%p{$NAR#75jrhTLWM027oI6g1Y6EXqnKaA!Q2>+UU7XopUm1xl7#jfQ_?1;{KVxU+Z0}V37|lPydh1b%?!F=kCx&P=~+NL0Y8?B zu|&ENF&InU{5X7U1`Z;eL#Z4sNsZBHsD{@_6vxoGMCWsYps@V#x^iOE6+sF!_cNQA z7H+8~3m^#tl88G!XuWh!WnWQKAyzSor5V>-wQ2Wq&95>MUy!q_g6rKvM2vx zFQ5c8f@AxZy3?B!ZX68|#jN4sqP~^yYI2zLDS`fmti78VqCPy)*p=0yeLJhxbPvhU zBk$1zsT3E`<$SVDpxpdKXg#lGsX8Lc3@1?P$7Os%vA{IP{l}BZ-~7_RgjOe@MZcrV zi`-YaQhQ@~QP)y;#`$Nqv1{eKkYKiJ{yv&31v+ED{?2E;#+Rw_G+y^@uHrS00 z{VzHh&ix-b88-c3cusRNoI4m{401AT)Or~&m?J_QS2IV}$*}Og;cE_YG92Q&%~C8Z zl5sN3{H03_CV7S16c3YF_raO7X}>?V75HO2y7?9+4*CW=h5MP^_!_g{$gjgxHn`fk zOuJ^`#+aslMGP!!9j!g_Vw&TIb+qlwXWHrdmMbTR|w1kE8A0l zFI5xdzAZ%|d}ExcxiIK==AP+Kje5Zp)iF;4G+}K;b}X2^*_RJ;ctRvFSj&`#;3QqB zkZL)YaL29ByEEA8g10_jfu)9ct0ZP`eg5w*M&)vcugSy&74wUI@UvQdA%!RX*n}e# z`uvXHg`0PzS2ihYR3Be{zyUO+nlv}z}((R%W!?% zJA-a44;s1mWfF>5#XRUqb8zDD8gipw)#>-@fLp`<{!JIBI5z|le|7V=rprSpw>R`* zYCAsjpt1DZ2WcL5S}91Ids}rj_H!z;+H&JHhn;r6oA)3_KKLuRn3;pFns zZI?`I&5il%j`DWryPAz(QIz;F{jkx;e7Fmz$ODv?#^Ds|vT}rkR~{VdoGdCo+HeJj zPm1S0@{^pw8JfVxJ59!Lz2Xnw`KL7cMz9ZTrur9X3(ZiSKN)ELdQaX*cgrk+ zK_?n`R0fT74x7-#0j6|(W$ihYIOe(Y68%g}m1EsA3mkcVaJ!GpRWW;~P8tmDK=Xx*+i?^;fUraKN*&xze|izZd!Q6UWU& zmUlWclH=ZO^7yQ}k)0KR+gDafNyoWwe0E)=bJ*egU@le!zSEG2^$$+vHR2+#Cnnz% zKZV=Inc_L+n8H-}CR_M_C)+?99;hGMhQCx;;B0LOn5O>^vJJFhd}F2!Ie)n@=A)=; zd>y_-r(nI3*4R1EjMTtbun!5I3|=|hkLu?K3vu5yA74_3eT|p14<0R=d9oqj9gaO^ zfBDgt_uHz|_$Z6SX0^P(@@TOHrDmS2@5y)r^U4Efax(RHk2N}Bvjb9Sdx(7)Us2jG z@PU8}Gvh$6FEv%nwE0J+tqOzZkbkE;2Hq7uB0{>7dfDBhvlqVPcFT2~yntcA85eSL zuf@(>epr{>&-AYp)2A1$?@w^z9#vBO!yHbrZbbXbgW@&5 zn7YTE`63%QIt}r1A`ZmyzEyspsC?h@Ih^137u6&iK1!SEufM|$teW(Szr2h6uptzF zYNG$8SP9|!!|*?o^;mD~!Tt2iz27|2aIiHiUA`AoN87S+{x$zV(foaP{sepYSu+o_ ztI6$z>1e2EeqVT<_Oy(lB*r6SYYg`tK@J{T8Ddgw`8|7i$qdez!2oU7@EvQNF zLtt7S$qr3=pA#E{R8)6(`NiRjls?4&7Biq`)0E) zs_9$)3EM=kh2f{J^uHc{>fS8>>o_Oz|JHfmZ(PF_1ClnwoxcP^gI?1!6LWOsHwKz* z+bzFuSm37R?^rlZRKOhtR2ic_|8w}fGT>R2M?J||x}b7&9k$sQqn&$^s6=ux5&arA z?tg`o72LsT3t|cHlXN#5QCF`qK#l8xk!Ho=4`rXLulw-Aw>(H6C+%0)+H&2iPpVJ- z9gEj69^t3%$!Z&?_|NL6kq(ESnxdZ-Ocb+~$)Gpfw6OEn9L%aYNInsDkXdPV zXY*C|{~K@v(QqLA7?%5Arz#V5h->&J8Kh_LhwF;t4<{uOO6VxO=1259GYcy8ztGYZ z=^;(M*Sy|)_O@P^_8Qx0QZ@c}TbrI~+xeA+tiAtsJHt=K7+XKrY;7gvo|EP8^1lY! zWU$H)W|bc#es;R8f=^dx`9*on%JT2^znle)2BelVnB@%S{2o6j2e?kM!kTxQ!4%nx zw>%4rUHwSnXn5Tp?Ao@T96j6(-n8Hd(tHQBIT##=0^<&3;4;AIL(vvs93e2=(KAdG zWVvn(1&J?ukhr&3yiRxiUO^(gdeP+*$Lf;?IlRdE8q5pB3nvsc$+oQG@KYBd2MwJL zB=}#IN1namrzY`@5B~QATsQ%Et&m~DRZmTi1^_n@08|%vwdP=s>HN`1D~?$>b?g(? z`4#jKbeh2FF4ShIgtB!Ks5x}@qVXW~Un!fZr))~S`(IS5`+Om;WA^!9X45!w2mU{L zjGL4BUH+Z@tpc0lS@T7(+TOua@*DP)4BiGaAiI84(uA8Q1N)tvKMi_X=A9PL=d`FZ zucIxN^JiyvJ#-dFN3J#ZD%9`Ga1+_Z1-A6jI9@~nB2vozlFr4U-ZvCi5iBw?c6D4` zg}ke)%bl%4IKJBRI)|@q^@VobNG_gxD5P`&5qANTfn%10!G^-c<1oPNtn8e zO8QexBo)pD?Hw6n+P0#xox@MI46Z0u+&R3A7+lPn(!Y76F^G||JiCwa7UHeHnt6_4 zPW!o*MB&4`f`?KmcMvrH5`59~Sf81?#=-Ur;8Rf}BLS7@P0Av(HiORV;%Rqf_(xXA z0oI>*N8(hthB+DP{jw%O?4;|^Myd}ZRoXC;&rbcuG8}#|J;utFCQ_Db$tTGGj`?NZ zEQ^a5LV~t-zFu7$yt?*_y?zxZ-b4LHoNHW2hC$wcB~dC~SG??7lJW~odVkA76#m_^ zjUjVW6A5p>GW>LI__5c)r~$aK?b$m{j1qzdBL^y+Q?dHr^ggMs+8U5(_~07yZ4K^> zjk?-}3r%x#0ml3#pZ3%?qKVMsTl7XsF<wgJTNbKr-NgU<|>wf^(TLZ<-#Y8pM4w^ViBnl01 z|AOIlt5`VBuJLTI9i%Mw`I@eRE@<9$ka&?RTpKotT@NP@dc;MUsBAq)b+7@~tXw)} zmE#acd#Fk z-AVVsCH0rfc{^xv4|vmlGeq=ZWB@)ZpTelZHC%LLzuWopQGZv_2@GR*V3#A_fw0Z~ zBm22@INJyI3}-h6IdXNqS$+_14nCP14#nz!Y^cdl(6C3ie>_ZEJgOyP{aESpc<7ks z^^a-(2aai}Mqgu^Jj<9eq_OzV)b0JI^W7IRxI{7}@t^e&9oyfc$B_5~HeQb*@m)4v zk0J3g6i+#N42j=s-*0}qFSK(OUMo8#i57Lu&RgQU3J=U) z(q%ReyM1_y9Buqn9_q@Oy1vqvy#LUt^wJz(yP1sPPA49Tk`9`V4ar#jE2mAx&ndEh zD&XHYRp_L(S!=^`BX@hkI`M}D>z)2bT=3|ccD`5E=2X^>P33d*w}_>O;LiGQgC{TL z{qg(to_F%Q25;JnLbKeoMPS||gpHH9M4Kw3aCA^uum2OP%x$;((;=+vfV#dXIi&b~ z`K(doSDfue#4r57PUnp*;Yw$FjPJfWi*IX@@d@1i0QFr-;Nhvwar$#k`f`V(mMS4V;g4G1TP@spz+yZKiB-S0KQczZ?_qznZ zO5)~Y&jKIIBW;DFGcEf^cUd$w%w3inUq0Cs%@H?a9!Eypr5q-eeq*P{sefXTkb39l z0NB-zy;#P+c-a$+Zc!YkEP~a^Qgqs#U7^(2#JneFxG&8iKbK$0XJB1=cr2njjZnZ{ z*GCP8QNGR?R%vG?l}?Gz#Xbm~s>(&O$^FJI(l8U;Z&p=0-sQKE=_}2r>DK5t@@4r3 zXTkwB`@B0Exgxhh29}sOD?>EjJ%+B`m-0~I>`y=5OON=HukOq4FAe+s)t*ZK+nZI? zhx!VC@#-H&EzfoS9IU_EJ>|}g>_|t_rIF@8iUsI)wq~cRqIJ@nxs_#reF9=pt(&Vf zyR&_nk2Cm)YZ83gP*B6u@#VSkFZJ8nbh|dAD(Ty@QYE5CNm?uTl^dUn?X0=7mWXs& z+4@E4Kr2uz9u@6Kyb??KXd&hmvSxJA!VWR20@V0ZU5=Uq9 zeb!Pbb9{G7dxjmuDJ|`H%|oX*tK#LObtjxtqZ`i{8yClOc-@f}+%npRfK^DR=qbEE zLW#@`LLP{3%#9JFTPx{ky&}+?V^f;uO5xFd-Fe3P+0aL*NpseXVc!0bEGRBDwwn%egEMv zA1y`f_n32H6h0la=!OXj%!)IV)$FK?y@})z&Mhc>hj;<=>`oT)&SKI!!XiGTN5K7x zBu8~&6JEDO1I(Q^9zqZ{z#Il&)jKLY*LE*nQI@W#be2{QPtPjz?woQ36=uw!!4F~) z%C>%^892i0r)mT;(hS}}8X|6bF7DV7h@@!*i?!+qJ4Sz0BYK}1(Yck({hKtL#R*9T zH$;VMRw>k23r++Q(u-w&jGqIUhz_q4al=qhg@!x4eQF8XtHUaKA5e$V4P%eI&ezDR zX}9ypUUCLfBken6Sb&uNiqswOVSRULkxCEKITdcaV6z~`!t{6GFgSmT5WTY3sHdf} z%3n^i7XCaEi&ivIw3wL{g&|;p{mEJp9sXY=KPUFYFK8IA$p=x(n)JSh<8pPIYj2+K z{|xiN_4c{x(kadNO_8xMgEH<_X2z@p`G*KIRb?FKP)k$)WSNnRmzJeVE1jE|tg6gp zS?r;ctE7OQFmvRXIU)aXEWBChM$g(p_tvvO_l?xgfvD3xin-=^ZITNU?43LGX=3Sy@+~XevRuPRghXb^({!JaB z1E2%qh(KqcO186|O_^>C0;z8>?Cu3DQ@{hj(&hG0u+l^%=B>>KE`sbfkm)S~vz3*c z#nImgZx3BVK5G-aA#h|7lljuCKo98ycGJv)y-a46Zl)Ki)o2iz;u<%p#xKSEUz*CL zhXLqG@1F_Ml2QpKW;~EjDUuryY;Xs>Pk@Nt4&9|XED!wMwBAP)*O9!Q(H{h;?@24~ z?FjJq?|dA?M=G84zLO4Po85!8#y#5Ovl>U^xF*o_Mpo;*D|{6x#AlP|DE%)ppj&M8 z`KUJ!>3(p?QfF$VuVFx+pXLYbwqZegD_7HA#T&&0QN>&wQ7gzNPZ+2l-ti7JLGYel zDHDO00`pnRr+Q#ti?a39e}=3vtMOiy^gn|C=3V(fNJb7$vf*X{RG>)~$HVHZ3=--{ zp07HPZ&UmEJh0A&;JQ9{jS7e}kAZ^Z8zgqNneAqPoVzV@n-8-pSTelncZR-UmlIt5 zL|8wy*pOD(NUk02Y_oJ*G6GbCzU!Ry5H<`4>-F9(GI#ByPb5FA~UDtJ&;kZ z`qP>94D@!Qcm_AK@m!f2jbzAKT3;Mv3^Fur()OJ*ZdAkwjOvAX7~*^v^ilX8Zc4GV z{aWF#0gH(Lb!3d(6;b!i!e9H}j^EB2(Vl?#{&D|`NMW^P+k%N`xbT;lHUy;oFBGz( z5)HSw`>atQ?#`hr5a-6g@Uk|?2|LSIlQ+FcUrDv1yZDf9(} zBHe+4E)Em~^A%iTf)lzS28a$4U0}jXOn5xueBukbFEpVggszVe98ctgu5)s~51VFD z!9-#v5Hqp+`k)CeQ81Tagjh8tpKz40nyLzN39Bo%f+du9PM$3*)}512s0%?e(!@wJ zxjU!8#;8`sOr?Z^{@SPTmdBSVd?_>GB_>=+xRUtE-PcD=aEXE;f@Q=`?Y=%>f=d+S z{v`kEmgmBW^#b7jVPB<5vLpWk6EuUL-?ge;@n-zBc(aQ;4nvrj{s|EjmnUrrmY+F-F+nATdG|Zb9 z0ZSRNQ@g*_LmGG}W@>IX%VUOU-1h=kTy@^t9iQFjj=ZYwGe5j4!)xe^LrUWk!R~Rj z5x4}=e=+QgM<0a?fXYx{(+|!2o*#M4fItG{O(3Df{o0&Fwe*f+J7A*^aRmnIj^%3a zQmNt95_D-vbM8;eEbg$(xgShyP3WP}YgL1T0Z)}#d;#H`L8{DKXNWhj`%K=z)*1c0 zfvq#DlOKJ}?48Q()Ng>HFm6aD#0!lzn0VQS0iJ?{=A1>dlPOG5IPeudo+#To!Tlwg zGiJ|A-sCk$Hg>Z8uR1%YN>_qTC$H8Qb`CbXENB&bP=Z#0^#EB@^q{uW@Y?@i4lKhV zq(jVuyNDITp&(v0-pNSYo4casU3;OTbjW@OXV{W^slkb&Wtp6>yG%?P^m9#k<+R{5 z9M$0+UToRF&BOiJzkMWFm0MXM9XF=N8Hx32#5B5wI;utiD)mKo~y1E=8QdeaYD^Ls#!iLz2iz zM;bTnwh4TQYfXATyv;BTbw9N~Rgrk$yXtwSh+zDa@UH{0itx4|>KwH&k(1^S`D#zm z?v*`M`2Xa+T`GEk%)<5d89A#+obY7F^oZ@`b;rO}kEY2o)Xfphi zYds!Q=xjWu59BV1DO5in?$WtpF8K%ZmI7#DcO>r-J#7s6r#|iRm@ab9P5TXp$tGDa zkmURUPScO$DEWLTWSVNJWz(M_{HC)0oUl(artWMOu>3Dg_X*h_VOvt|7o57$$eTEB*q=^ zcbXdT;G`;$sfeypn~%a@@FuFdzax^;_9BZWp|6GD3ZfkieKG5fy=6bD+?f`e;;3_M z@?QsXSzF^CNJ)^W{a^UZd4^k7_Un1&-84HTV zx`(rSU@RaP-CfBhI4<-%Bcs;Ot%j`==T~%Pt_$C7R}+bJ>!We?op*n>JA61#pgW{HKanPpeGn`6NatIId}MYFgO|D~bCMskahO|Ljamn| z%m?bls1ma1Cxqha|D?utt`ZUuu5k&I7jnAn=Ay8 zA0O4yg{dNl8-1!Q6p{rguPJ-C=JS<|6Wo_lmnKS2CFTV}sqD(>O;`GAk2PhTI#rx* zDhr&GeQHJ^)bwfJ-3O{>VRLZh%Zai)(p6P9O(ET>8F?Y&OW1fx3(ZD1#|-==YlhHh zlLZpBSIXV+#G(u90XJ7_>EK$2v7PsL4 zbR;kM4lp!KLpEc}3}Zg<`=GSWvS$qc$Eklb&t&-Vl1zp_pz-Ks_?JZ{!!ncM(L6zo zN9Y2&0Bw;mdlFtN3SubkI+Je{H+}5%jptx0o9MFAj}yv19+mkRY>?7~u0oS+2FTJP zYcQ#O{w?W$t@JHPPh1kuPv=ZoG}Fh{bKdy-run}A=>B3~(!J*x*Fo1`ciobB-k{Ia6YawvX)kg=@K~jy`u{bZ_Fl{TK@ua#mE3Pl`&A6e&H}%32U*N_P-$MRcDeJ($Rr-2J7x-zVZ^q|Ke6`i&#VeEy3!tKGu~N2p^%I|~i9`jy(Cv#T$8;RfIepTs}S z`o21r-1)$D?; z5b_5kO+G{}*OZgopx~=bZ=8g?`vS$U-rqQ!VBgn{q{+G-1H_f3r=F`VY{D?)Wlg<- zx(_XNHm#=gth#fWHZ>FQ*9CqWNQHjtcXxLD6sMCNKh5HYbqJ0^WKNd{=E`nTx`-Qq zhTDa9oA#*1(Sr0U1==F+^G&~NZ#ve_sr$92-(PiRl2rB+SxqOh?z$LhOE%j!{2V18 zU3G*d+}7dmGrvbuquL^^=T}UtTD`ySKUG)#1J@ZtJ8FwCrRn>sY#N!vTWR zo8I)x6in}WN(w*iuHxZtPzlLVY|;#}eT#3{OI&=zK7KI~s$^N_#Wlb24PApj40>sK zrE!YuDs$V2*2?U(qoC`m97SZM9R*!iS%?Ux9fcTy>2-TlyOAAf-X$xP7}3P@h&MVD z(+i@Bxv|YnYOozJqCyFLIf#PcZ>bwATZ$Ox^1Jlbv?43#&g+(L&h~9dLro53iMspj zjmDV5}bl}FM`JBjf5Z8E$=3|GWxU)I!YFNnE}r)vvF zOCaWND>xf*)JRO7)3&xqL)jW6utNbf_|_KfG@)#5kF)B!RaJHJs%@sCvo$x2%}>TH-gm+ZakH+ zxKXp0{O5JY(jEf*?EPmTK!b~tSMWi|G=uGaLmm&?W%G%pKsxq*WN=3phAg-(G6xujMT{9=cpt(0lccT zd2L6mDhKP&qgNj5FFc(y)uUIw!|q@Siv7z5(F#wIw4-;zS1rBbd|b)1mS6aNC9mFm zkgr>OPiJyAkQ059bXsQo*lY96MwDN1>+Lt^kDq(}<^8n8vYS@;(jR`H3(?W`^oQ4b z&$ZsO)qAe?o=x7f-g~a_p0(a{nfJWid*0$bmw3;`-gA-nT1}QTgw;bg|NAH_#exmre|M|E+XURswY=Gpb>rZCA zz_d!!gp|A)Qr4~(j~_PL8X=|Vw6CmQk|ICMoY;e(fxitGxzRpAhi8{zyB7!*?VWsoS8W@bI#0} zGiTuJqS(Y+j4)ZCvf?@7yX}49Ie=c!3}{tMYKv9LY4D=L0@=C#I;{K?8jj)+Rcpc< z--A2B*cKLoCai?84+ddxvM%T-nX|J1grZO0WFtw8t)d9_C;6_Mfl&C)+QeUxB!i#f z`=;6W(|1|1{5zkKZ!H4@NRr{mUTnvwge1;uEku_aqa&#c8k$#}lM6$^vBcuoJeFu2 zn?Fi8$4`^bDFvQCOF4!%hrbiFAhb3(&VVxyu8L=NSRJ6^CA@8;*ka;+%0rS*i8PJ0O zloRdE=+D&`^eQU0%8F$^6>~wBiiP|`npcom5y(9fGE-tH!27&SDS3$2auS)!Gs<@z z6WZ_PEqle{90{=_e-H@R(G#K{vxRw^UT_iuWiiV$N9F=k?wgCvxJO|sW%DHDp#RL3 zSNIj<>^PE|`I*>Sqd}=A)UOy6LHshlBpLo`ML&~}sHj<_cT`HFeG}>N=*`6jZ-*=0 zgia@WBkk3E*RfC2rK{PEN6K!jXgpORh;WWPv=|#TR2(27a%6N$uQlP*+uo2ic0XDDFfrJ zI0e{s2v``Ad8UlWJWKtYt$xNhz4XTGNpH%_JR6Ada~3h<_e}i8cRh{d1PMEQkKh$6 z8`}u1cVLIr_oe!MotsbN)W_M5&0i+GDMKFZ`wsX34{WDSaMr*Cgk=hN0zFk0XP%fM z9(o-6EJp)$hP1Ovfmubmqu~jB$!0WLC|w*h&_a1rPiR22LAu$>8LE{t#JL0#MO)E~ zY$0t`9|n7dobe6D)Bo#@2v6UJSMc;hm{k>v5LBLE5*AOtvZ4jCB^90c8{z40jG`Ex zzA6PnG93f8Yb_df;(M-&CW-v2GXMEx>^=Ar1sxczh`Kov#X6dd{r#iNG|Jf7I0T*& z0havoC4dcJ?4wj+O~yW2eQhdJ40Y2U$$E=7Wl1JoyopS@coSLlfYA`)a(|blh;qFm z`E9otTY<&cZcu#JVzT)xRSd7YO(lzG%v^$9HxW^k2mVIpwntn8z8UPwW@HQx zy!-!?2lARP#XE1QUE(GWES@<{^3U_Q9`Lnbk5OJji-cIC&Il^$q4sQcfYbB9 z(8n|y0HhC7Vopo~tycZebW+vygL=%{^c?}$4ve^cN1$9EP;ne0HLJW=Qeag*j1|M@ zdd6&8u5*^~4Eu0fBDpGAe)s8{=0kNlAe;)$wnRA*!JAkMAGRhIM?(N1hQ3!a_ebK% z-1Tx$d8k6Qyb%(k`RJ}dX4eUaM3=`bJ!sb7qxr-qiYljU=?OJ zN^nwP9BZCa!T;|CS{dI2ql|$C3M9#*$s*w$UL)h0Qk#;+S+AhcFzLd;N`ZvPdPGKG_H!|VC`La(qKJ^pvYi-1VfI4wHTZ+*fkSUu)DWO?=vTR z5k0}1k&zir%me;N`aOsUcAd_2=9-q#alsCRpB8`lm2}0ze<(Dil$JOfDu6npxu5YV zrKLrsHO}(N%A3m+nV0fuldq~_wUriB1+eRC?saJt4Z zn&%@O^1q5HGVo5U{I&95LA*&oSyJw1O7t>qF2eY41AdWqA~EwHS;uT(w$g56+7UOG zFRm@GtH>*Lm!kBUfWZKbl<=#1eGtA#C{E`@x@cRSZHiGdi#1iA%5Ej9%-7ATaTTrt9l`Qs63OiQw6vSd9b@8fCwNA(H-dnsXBYZBM z#Jo}%mL7<{LzUox$OTl(@T|u3YdrS13$*EYuEpc{ogFr6InzUqHGcr~;;`1$hTllA zXXs+?LU+B0Koju6|CE6CuBQe7!k@FxmSNJMs5cG($0-f7CfGA2_9Njbvq>iRd59VIN9FkeKHXHg7BMlL zL9kq@KeF11+Y`FIDK|Xc=DFdhGdb6N`(j^C*fVdj?`QF0&&~L;g+0?TS9d}t*>k3b zJVRTZ$y%#3N$ZBYVuq|7|NZnNU<4v8a>YzABrKrq#Q|r$m=gW4iEMrVP|j^kpK6UR z$aYva9f2K-$iZ%r6tqu+&|vsI5kU(_!(LiJ-HdZ0_u0fq1-POLKms~kePBFx-4k<` z_tz$hWo}HnZQH~rRDZTl$C>=AofD6`PMu(~N)SkUC15KSu+0q5%b)IfcUrhecs59$ z+v8}c1S63}&Jc}2{7;IUA&Y#w0vx2sGCo@5?RBcim!Go8CnWHz1ZI&h{wGDw5+7hG z@=uDKC5!xm0vx2sGCo@5WV6UW<05BJDxZ*Gf32*eS!6dKU|DiRw7jx~=XI3MO)aFi2^a)hkM25}!V?lo+g z#j&xyKRzkL(F&*Wmsq&nfP+ssF#s}CpA&G7F{?cnQbN?C5kV7N zlfp4qG6pxP0})+g2_M*e0IrY0Z9Wt$(b3?eeS69uNGlnWvV9Cc=HsK)nW}BY8sAhV z^&xXI_piX#gI(Rr$=r<~no|0d0&yvuN&Dq7@Au$c@(TLvV|}F1xD`t~)@L2EQUZ#T zx)6?bisRVnFnYPOb4fldaBPqBOe>0yqI
    v5Ma;$5DE>kYljlQnn3#OC0Z zIKZ(EAe+^ntb$*Mf*a_7?2c0gDLZ?fEc=*f+26oaLX~}t7;ct*K<|ACM6${r+h$qf z5Z3VQ@#EQMS+Q;ARcQ?8cuBLYm^OP9s?n3$EK58LT+udT0^mKl&9cN20HV!2;6y>= z-4|^_!#qJYAk03^2IRe&AVQXy%o3i^fW$3{kQF7u4(N>(5we7xB|!rYsL*Cm#v}s9 z56O>Pn#m1P5?ZlVgJ@1US6&%BvL?jcK)SP(dzG-8=rq28rDp1L_y_m?lQZQD&B0O< zpg}7xfub@MXU{UI*Tji5dU>%UW{ha94k6PF_8Q=#2}ZB+wTU3dmI-roK;BDN&bAdv zJjlEf*IsnTZ;68z>-O6s^Tu8lcR@iWce5&@Upj{A0e)OdS!!+ za46vEWf74rU0BI_pw6pW=7OORmAoJ{(7;b)bOvUvqR?cB_w2J6i2q4O`(K}rznfa% z!p7gQ5U=1X4Lmqb{<6kWMgR84P~*1ypR7OxG|EA78+0VtsBd5ZwbGM~(L|vFF!#mw z>3h-GTw^_Ri3Vf`^tEFDJ>+SAePcj>MEEf-+Vm}el3_0e^ljp00JQ2IawQ9^6HJ-f zbgDT32xyE-{dw351lG%H4wu#ZIkZ&~=H^9R2M{4m&a&@-;O^!PE7a=K)}+_FvKYHW zpMdis7hE=ypDMcU>I*~Zn4e~j8Lm0R4D1J>iy{1et|!bWE-%ED(I_r4Vxvx1QLs7| zvoMk|SMVLzR;2oGOUGXN2N(zV4tsiy{0wnLG~NLlhWEucn90iMuZ{dHk$PhE1E7Ny zT`9iC5aB&oEO(_@0xrkIBVc|gcWZtzJ&h_G6y;wFTbEFXjW=>&{ASdpQU4Rr8Ar<#R1=mbp0qc@u6j{e9BnUe;K2GKjf=cGX;l9)4XKvOgm!(F=Kzg2Q5CzV%?Msd^?}d4*xM?%h_NdeOk-ei<97uie5xT~h>uq)CL1 zhwmIv0RKRWwIWuQfrv?KSa~@%a}Nv;DBM>Gdt|UrM&(MHE+9?QK+{yD(2U8M#tkIv zC<3FpO1TifSWlLM7#Gyq|g1~d`xZ5XF(cc%Wv!#UesW9 zvpdP}3Hd$!kjC3&ap|f?xWQW?JM-fxYZDn{a-e5HL@^S4nPZ%_W1K8<4U60ijXmb7 z{ zPqJ?QCz+e!NeR5pHn{24OVM%u_S`&wAdj)@3;4HzetC=q6O8(7L%xe{(0+jAI0v(P zw(qhptoHTRtCh{fb$=D4r^htibIpB=L21ZLP zgWn3`OY*je9?bd4f3C^(H>4st&Vd|VVaxg3%0%HRLlJGiHC!#S#cN6aDG0+ExcqQ{ zz#izl#{2c%hMwhzn@T+sj(iP01FHTeeN3a?-lV5B>L0Z>&|kdft;a>DslNL0aVwI1 z^;vQCwpM)%H1+8|SmckvuYtWek#+Q2&_%sZ!n-x4C|iQv?S@G}gb9WG6+^to!mSM# zBPb5@1GDx8SZ$h~(=cavj7B=r*;rsb+ghCWzYO5(_C~ag2teZl+w=8AY#>2-56(Ky zoA?&8UDG~Q6F-K-41YrgW7S`;Jiz2yD~?YCpKz^JWudH?5ep%X`^p&K(W;Hz$!(L7Z*^g4>9|@!*G)GOBP_#Z;-UoxW3Xj~lv&2>;FO zDB|m{@rHiK&_t9wCWV}XtOPc*cegc6K)zBM$UdZIGt|a7)?@eoka^f8s4SM zK$+ggSjHB}G_xkpRH7yUqQP=?>G_Zhviy#Q4#02Pjj9xzkoUwwRsyo?RTJgiKq=SY zjx|)9=C?JBA5biDeQeT1BsJC(!YFEq%H&tDJpp;>IY-XMtxRpPDf`aDN=o9M>3OdE zdb3=g+!a%U=K+!<+u;O6uf;jka?WS`|K!1@qJ>sdwBCm1W%BcMr7&5nco7|s#Tm4i5AMKp9$?1~|Kz~aLC z5KqUTl?bk9z{{$)zs%m=9XHcx?fdmyyasH!*Y%=r-20We@Q|Ylvs<}f$k|n&#;LAa zJwz5VxrS79is!KZn$x@TtT_SsZ8BTA3dl!eOJ>_C?p07{%n9h7CWu@OTwsA57W1PZ zhhsrB1wt|6IqjtN5hfIJ6&7fabAew~%GF3iF{))Ekz(~VsBKsjIr`<;7>RwBlgGxB zq>vmGozSCUP?&9ghHB*Azp%}xs*iQ-0FqS|2O2b_D^{gTaAkm69485`EaPQT*k}bG zb8K!)fS`L<+~123S!xyA_m_m$gjTk~U(pIHFZRAJ#fE3}Qfy}oUkh&iV%)YT$h7;r z$oLr>*Ig9Jn+{hn3OEN*4Qjj#d6I!#ta2%_@o5DNTFef$AMb(nOgT?HHU=yiGRmyf&5@(|E63r3(iJ&1UGCVleD$MzjDCU5uU6H6{-^;8? zoK*)|6hLf@K%5_mVucXZ5Q#Dq$4BaF=Da8Zft+K=fW!rnC^NCmqL7vIMG*+(tSBOJ zAn~wBl$qFWb&3njp0mCZWsFWpfB7RY)&MK$Pr1*6J;Pg%yXS|w#EK(mXHH1NvX_vd z@ig;5ekG4b$dM!VV%`jUwFfW7ATS!115&)ssdVp5-}l;zQRa+qzgU4Af)Et;e8rA3 z9&l=e`5V$A?-*^c>}|f`jS$W|I@UC!{UYNo8&J7y&<4I;B2)QZXIia(j6!wc4X`}B zC$Ye{yBWy{X1vZpYFI-R$b&b$aXbmTH$QUjB(`zi!_VC)#qCyouF}u+z1y5`mOCJ^ z>=*f8vb-!cHGAt>P3Y5OMn=X@_xz{D)u#apzPwP~6)Z)Rp?r^=BNgN5 z$F~+KrDM$=e3GF^84;z4nu0XEhidG);f-&T`o1(ijDEoi#3XAmFp5dgJ3|@#Geb60 zbZzkLJT#7NOQPmAul2@O<649v0A-XC6gL1E0anqN{SZ#+vVf~TQM4)az12KLcBLCR z)4her(wdAv42Z{dn~VK2lcV8Uq#oFLMj=3vSG4`bREl*ct4XS6&i6dyp>UDD zdyT*hz;AzvJk16w8!|M)>_pn1!F+ImvXVJUV|AFbd&QePC}Cvv;|3CiRoO@H!O~2v zHpG+im6S6^OEJ(4`k9hqm5h_jSt0l&dyA}Qi>cjg6YoN26UfK3w_n`Fg)7vwo%AoOcX;dJp4INtJK;~d zBmOl=1+6>IiM5)6s|j3L=>M*ag!dA5jnlJmJ<`32Ik%;(=tMr5cL05En&BERUQNNP zgm&N_TRkJ8IbrWO$l5lgipx()2o_+P&Z%*S6ug`xE1*mTlx>oCINZxis*0Bd>5CPd z04(oy$xo5R$2WNC4!gMK>WkTp*Qg1Ft)fNVcP&Y2xi+$HGVT9ClUL)Ua6@PXB@}fOA~?a-iR|}^v54xvTt%9pyeeX^u$`QS!C#Fg zjcuypBaEcJZnTVz1tIZd#0$j+jhS632`*lufqf9r<&)0|f+#2;|NC}MoZ7@D{LZ^o zEOoHfoe6qY9D0j7$0AFZk+bVwtmafFV$Z{^9Ll7vnJTR|u@DH@hvgoC_+|*_U8(3m zT_l`38dG4NrWwx{aRn0GI#2YcMOIs@Uq2OWf`Z*kSbe;s!3RKdg)|uIeYZ)}zXv#q zjM2u*=;`BRsm)s9BI=c9c`|bJ!z=U5LMm#SHQ#M^?9XsPy(DUzSWetxC+O6Dnwf;t zW;s4F^p2>NqkARwdTrvDI0|M$VaTnh;Bd2SJ5(MFE=2Gi=r7yES-{TgpxzgUM_F{i z{pmcM(k8wmKa`PwL!|$yjU*Sgitc|FFKCQCp4X+J#y-z8D$nu$`!^6q(a3-Q6ZiVN9QEe|u6FV1(|m2;-VX*XZh|fd%XY9g-0Jb6*#9w>Q}BR1NmY=gc>m_U zaLfj`K&pWLyhwp`3Fz&@CV%@y|Lv4H-$I;qcghWK?owr)EOSccaKEhGd)*$avXwL3 zQgmU%sdgn2@DIxeUvuhpv{Q2gXuE_+(K{c+i1fGnlJSMmk7X#1OHlnF*4PkQ2L-TF z3G7W6WgZX3PDU|KXYzN_lEej`v zD%V|uZdqIu8%dRS?6Pl&ifm2X%PMz|_g*Jo!1lN(%KfWc6wSbo_@YCWp#X(Y&~Y0H zn$4|4?Be_*c`fzQ%GSt~$KHCo<~~jKC0HI8gF--B%v3D8YKR|RXpwrqtmn#_8!(C(r{Eq?mP5&I9AG7?`t+jO==h9GLUKlz*RjLe8<9G3|_ut#EAQ zYbw&LZR|$PCd5Rm8k^>UnB4l+-U)B8W0m`s9g+5BXgs-ZQVkx{!$m*f$aCi58xGxM z>!*re&O=AzEp*r)`2!Ydi^1R6F1XfA1-KAU9F4D)a-tU@7QjM;fCmZBuVFIQwR_Qi5Uc z2TZ5$tAsa=cOcy^>O_a7WW&Zg`aH4Dj_T!S zMOU#+Zu!|AqPk+F8O743_ zKvPZ7oiaEAeQd^{(4QjMNLyz-C3^~yIEnimLZ|t13mpwV#uNcWC_Z7U`4eb-$YB_B z(q?l@Y$P$q4$S{jk=+U5nc2o|sW8Eidau3XPFJU-bGOF9Fr$?_jxWZE@(+=H(ASbF zO?22^M!WRT4?6{#idX)MJ+<7obEwZYTn-PsU1?a+8)iGLo< z>D$l=8jvpM?(7xcETwFvLg<q^L!de1lB<3Eurb12yoz{S$aL(EA|LQ6?l7 zO|CxCbt@ViGY(fse0!VRj@OMgj=AgQ7*rc?p_nbV<{Po))|3|?{-NII86_!=own0I zm929L*p%5ZvU?LqfKa0B{BQZ2Mf{Lv+q+jGO)LRTL4--BpA14W0@d+C~>y0G(FVCE*zdg zN-P|ZGGg}_l3in(oFQb8u-8eeM{KOCu<^FreXa{(h}&KKz$2e*oDv~%!4tTz_8G$@U&*gGck@e4Jw4k zP>OaZyo-%Ca8N9R(~vhAGM%*1z(@YYS_tm~UeHdDLSrq^FaC@PG#ECn3K%V8uud=$ zy@MDU1nw!wX|In-2Gwo9_>D{kU%Kn zlXnQalXL2O-B=6b$1@5M?h*1jB;kfBbgxV&a8DS2%{ZQbZI%SrOOVat64pjP9EoE%Y7!EuGNRLpm=a0RM_!Jlr-@BP z$Rr05qt+y=p!~&{X?HY~<1Jz$1%3d6dwGeX@*vxgmHa)TN0d-#Q2a$;t8EY5a`SybS2#p%SyRP})Z zrJ#^#uY~>Bycx!KboS7=8Z5m+;Q~O8Atc0)ON`)~V{;!4r|pwgO8*0WN50>)qfKuC zNw6$JZHf)OjN}0cT4Qz z&JQUX1lEmMQDff}d#<>xOeUgF(#^Q3@@5&1D(*uZFQ=R<7Ep}pd;6B{i7kOk%)@GW z9tv_kBqQ^8<1*vy9B0ak(;$80#QqRvf@Ae@G%(ib$n*)BX+5lFFrJ;+j?D>Xe)YUK z7w5I){fl!&4@9I(d<#i2PnMJgOcnn#i*qHcc{brC;Cf=7s0fF!a))mHN<-g$4jHA&o-n1SyY332cYRz zbW8WO(JW3_id=8zvQEzEXuKpdx;Q2y&auS912d8{I-a?ZW-Q014wjLGiI_uu02o$h zT_jj$v=hOoQCM#Y7wy0?LF!acJJ)VG6!I`rGKT`jpcEeFY1~~Iv|j~Zy9vAqDrhXS zBwu@#OGA;GjbpzP$MuC_$4!_E$00`=q`!)VR|We zP^OuqGzaQ~IZ%EsWm!KqSj2Cc2JP@CqrMjxo*N57mW`FK1$U&wuB-m&bI&b)jy;IQ zW)HHHX#aC1==%FCx>sTfRYtT4WvA*&jnD~k$~`Qu&^lU2lFwl3TxPqI-Ie|3D$JKj zvnxn5xmuN7MjmN;>;?{*@Vbu%p+@GMeXmct<)(+Aa&Z zCep!2f)41b=5d=OsVUo=k8b|ufOf_?ct!UfPCTE((R3Jcw?QrR2&U+y=YI^OXCdiH zuX3t?>OEpylpeieF-sFE!_Q?IER5gJ;ZU1lmVwQPv8LLP4Ig6eA!9U8S&Gxm+~X1k zwB}6aUTftp9psAX(fmVV&U{ezrU-zO@bvW}ORM0|j>7kgi&R`lj737zvgQ{^gcB}o z?rn34AkIR-6E2ty z#V;%v6^QLrF_#o|!tR(G)+`g82-H|$crW97gyMG4D@w&Rm_-J=KF*72^%$P?k#&eP zBo=`Svau&5S>$$YlP#S@>^LD75_$4%TOO;@i?#AR*EURbG_glPB!~kt&~VzsA64{h zM!%`vIad^$6sXfKHmgwCoX^BS+-pLl2snaa7IOHmih)>QLd*~_Ga>{x6$MoHe3!Z8 zm=F_0p$z5BqfUj@r9thK!?o*fWB-;ZB8_d}+6D!wCekG^2zp$;;M|s2K(^u9COgr0 zm=w)(AsX6Jyx>rexL!q3dG6n)( zW|4*AoG%_=sPAVBvB&WzK)JTvOxPbwSi`wcyf&S^7LLCSXQj9mDg{UnNG>=?Xcg0A zFy0VJLH`ZJT_(nvZx!M^^Q}^x0TcorvCx-+a0tHSm{@T>4DXSsGRlO0{6oZnQU19P z!0_$&38HJnhy22uTm0U9TP}j;+Y0fje8U!z&x>kc%V^yy{BpBWJSC&H$$|2)dY6q^ zC5y%+t66iH%M$-q&Y)1m8gL2Olyj}N-pVNtV&+&e^TZXBnrJzc7>V%$SrVQXqoTML zy`EZ$Ur*z3`4wgj*7-SePIJ^md(h;%-N1D zWshB1<$+i0p~x9>$Zu%s0{T(-y`)P5aoC(54G`nOOOQ(va`D!G7xuu8_q$v}KkA2N z=C^Q;x7g6XU+j0<<$)O~8{|C@lh{*$zPPS0*w&1aJW{^N^U;*d zrlwM!HT~`ur7i*@O=Lp~K}I{){5MiZ<+Mm6dZsk!k>5PwY+MU{m2I1eOrC1p5`!!X zcn1JE9QJeFE)VHCP0C6h zG%P@$Q0fJ9-ZSy7oA^)8E7_MG9BTEYRy{0FG0Ewsm_iQ3lW8E))qKa0d*Ao%^n1^7 ztbPTx_k9^xd!g^ksqUG+FOwXr+Yr=sREE!VpYHo|sJq}s_g!6w5dyq%U8iG2N?cu( zpqNpbWRVA39|c*VlI!{!&=RPHK>lgAE;25L(8Rt^%3fZ$5yITca0K#J*+moNlWE~f zs9y0$1=Sk^l_JUrwT`$jX-pQ&uyV+0_ry(?nccz^fwadBM`PYYsc;OS@ShRD;ToBB zk659Q_F$@dCQ!*>$g1_EOIQze!*w|nVYtx+#2Qc7nV!Gl1AV?#i}MEedb@|#p5YB1 z^LC$A>+lA@?o*c0*7l-oB{hZ6-@b45qvdNd5$Um4caVVxK3D!PuN(QHnxm*mC2 zdle)Xy0$HORe~*RpXBIHHZ)2SQ?oBoEOQ+gtU&Xf83IGOSVmt4rK0XB2Rd z*rfl}7nE@SK@asExyO9iCZuO7RFhHw-V-Zo;z&j|a~Kcpk;GVML+!Ydk}M2la~U zqPt@k^v3c|(0Ou;yjLv53byMN#)xuCbfX>hmoL46z+}#k_M>@kZG)D4z5E2Vl=ai+ z+{D5PDVK&@;jUVV<2;!Zn^{xsT?=K1BNCF*HB*LsN9h5!>z_KIYqAXKj)ctUx>SaI zBt!PHZF1FdHkX?BP_u7^QF+8@X=1Mo$9ph=a<=J$O%jbAuS9MpMXs310)ZioX!yOrkq5O zZgabAGGuEcWPaB-=!q_|Nrr@6VuO_O0cD-`z6>=FRv_<%VhJReOVmZum$}5^$VUbA zS^OZ8e9Z%nBPOa^OX^jMoMMYLUnr}8fr-MnxiWf8{$YYul>=S(0r&*moG6(LT$+-%gFLE>thhzu zO^DznXp}^ENAY%F2JOpGm*}T|x9J{=dN50{AKTvXLu*rQ$Ht#kJJj|q{zBCEA>uDX z^*+byY3L_x6pN8HE$H+9E$YtTQ}6(@FPx2~Za^JaQC5cAF$p49h(|=QOPd5{y3g7` zg4YVA7a-d_FV$k3;lv7P)ICF$V*M@f-^gq!3qZlH?U2NlZzY1p1-%H5{kQzI=yw6$ zEAX)6mz}9=S#RJzg{ioIVLKf64O$dv$H{23>2Pk9!)zbISYq?09wR4J=fu{iP1?K?oJGz#KG;9B$Yw5Fe?b$bVtp!iVE?p~|scRK@)~wXE zZFu$qM<-zB|47&N-3puwbnTJ(x|aGh^1N5qCIoe@2ai3YP}_^&iUwW7WJ-JDQC(|X zr)#T!u4^wnqHEcY>DnYby(s4fJgLa9^Ow42`w)4(p=&EzbS)A8CBrS!1KN)84B&eK zPdlDHsFUryLJij+)GVo*>T$cPt4J^2hY$%MLC1{MwM#S`1JBWF;&tsuFx2TO)-9>z zCB=tniBl?<+*!3@h_00)emrWo8xQ_@!E531DS1lOqKfL;y4<0<<_5$*?*I(m;o2}~ zbyc0awsc9AyH10Prsv|c@Z?rqTZo5v_>9mJo$ktsdAy|I*$WD_EqF}nDB~U4ki6=< ztEN@nQ&aJT-KnKyq5^m<82+Ye!wECfvrK~3%|)GliW2d$;Eq7roTd%Ut1Z3L>8Y)& zu03McHTXLT^Ra+{OB<=#2{e64RaqrK79e_|rhOj^GD?9IRhN~sT3A?qUxp`rg{l@o z)3jv0s`QS^@-k8zu35u;Vvu-8;}VeSMV>m)$X#1qNksn*`c#5878rj|*M=3B)|OYf zC6x&E7)sN-C=FE&#n}6z6Lz0Jseu(gFlF?-*@JadnNSrl`EiLu8Kv zrWnY^;9)$UGc~(~CJU{<0VNvK7DYq3eU@gQU3$l?+OqOmVtEz?pAZ8=RA+0+04Z@- z*RW}`(5%@fG;O+;?5c@0>>9*wh=E|K$7;h|HIZgzPPd@E8K~2W7+RmBCC^z>w*vOeXv#QudoRv!!-6c{mK!Jx(EL4Uz6i{gUyxQuTg#hXW0H0W(^DLlQ zKPj(WI~+qAb>|ZcbiOuZR+U~=mRG&#F2amKJfB#Y3oIC9$Z|I$o=+@Hrj|@R?($kf z>_#k~ScnU?BtR@*;x2Ze0TIb37T_XQy~JHw>t8D3|F&n)2jOceN-lyWp25;^t$UBKQ&wVa0!ke=$EF8d_cc5vX2RAwu zZ_dQ%|G(kQc~9m2OT1a^1Rp0MDi{}WQ@%Y|{x@Kk-YP0d!!NK0%`SnK{IvX$y;HOrjFF9CAUjMZl8A2y_Ks>$XJg4FS6?is1TpnTBm8lN!IFGlWDW!gR%9|5w@QF!4$0m^*jP8Z;N4`r)#!+ zaCACR#Ka`bCpM!qv>}C6i)zc4fuj?~j`(NMX)G8HB=G2>(&aPCtL}7H5GE5ad}3h8 zqX9Fgw9->fkinQ9cy!T{Dha~s+={}sprA2Wz@shU!lokBU?M0z0!2YhC}`Tl<703U z=U8p15<#p!fd-RP=lrX3>f96L)CknS^XY+f%Fyiesy?f#@*d_lm?%5%pNq2d|FI}z z)rLhx8ELIuQm8fJi6Nx-0xdB@=)pu37z-lN2PT{BmlrC7U&9=1wgKve#}|- zq7(Cpg_uA&SXAw)D`#eI76=f0Vxg{#KowR0q@1`q0l_C0>M9mn;&RoTO72b^Aa{-C znz2zCiYC`Gu?~s+!}|z4Ymv!@A55lRCm%G5N-)xp*~ zS?4*m)pzNd7f*4eTJJQ@L3$S^uebl}>m6^ETJP*zsA~nKSOeXJbs2uwjw^(!>Vxq6 z;WCu01J7x*XD?Y+URzRAUS6iwDy(br$-yMa;h|3LVkO%&DDJI0if+9SiUime!tAP5 zyt$}9yr~~J`u1LsUpy>P!}89bUn~x$91n|a!;jOZboeG4LL~sAxNiaC`tJu5=2pcb z`H_MTiO_2^U;c)d?P-Vv%sbir;q7Ot_s{Td$i)8pAx04`uZT-WsZO{ePTmgzd4iP+ z%MY!@yEyiiiJFNK@h~WA_iv@|f;Jz9yk^Hb&cAgZAlrQCpIRl>bU2_E6bEwp>4Hn% zd{nlv0ySy$tw93n+IV2Bg09DdpfmG;%>Ya|L%3XbKP(QiuIvxvem75Q&Tp{}(LA^~ z$^QV~p#P*U8}PWnTH1X6iqvTM%6-#OXL_7xy6<{NeNtPJ14xY|_Z^TCu#z z>`fypyneM6Wvr8gTsmXio4Lit?+ZaiAE{}K39loN=@T%z*KE0KlZFE@jSK~fu;I~< zs;Vv4eyWmqpE8w+&pp*oCJ_{w zSgXKMP>!9Ra-l0ww{|^Nf;QfE5BaD3YHt?^cT*(AIBdqc+`75)Vz> zhZT0Cd{+ldR*=*hqS&4$>_!bu)wlP233d`NVbS!9jd)z@mf^k;f0NvHUhwA5=$>x; z-0X$tu|;LCTD-G6EM{Vl=C+{mb4kcnksxFFA!8?~SlRt#z_~Jjd&_cDV)a|<_!PRp zTWqGM+2*iymMPve38+|0dkQcdxe30zK1cllXq2@C}s~H8K_2Zow|Nt!ggGS<9+=(s9$_S$NUh zu#ka*)|ZZt@Hz-bTos78^JQGBio^T|ahT>HPW4whskCZwr&){hRIYP#USrd_i&YbD z+>H@6uvz>P04=}hm#Ap3DBvbWujkx>ZO(LNGfJEK6&x+H&D*BZjg}THVK;=^P;p@1 zsk-1MY+?KhU9c6_bn|YduQtO=@`$$*zYPb`U!dSZcdh+!mzH#|5Tm=HX`^1K-)TL=nRydCQ=D1R-w? zi!U?pXF)UMEo0LWd#m_)c1+$sK#+=!$(vFYbVL3!*%0Ov`_6rsD1ZOyxqV@HPR3PJ z?}5aV?l~Sd-T~jth7L;{h0Yv)F1Lch zz9qMmkp2xE68;VBe8wo_;T|OPuVp9nZ(yfmSg#CY=i8ovWf;n`@LC9)OuR#uIE($x z;x=CvqS+@}eOO#*xFbd~<%f14$Oyv0uZG)0<4~a((ExUhJ!|Sym~aA~3_K-sMAtc{ zU~Bf@FDq!?AewkvzjdeHZvdir6=+752z&XP8sYQ}9xxaCuD{4L0@b8gc!)LX9*M9l zPl^@B8X5bW03H-;a4Qzs9{3n!X_GoN_Yn6&RyV^9b^><9L@yNh-W<(61PEHi$p7d! z^9GZlFHNMIvojBCWcbvyNjouI1HZ{Otw?Lqq>Y;6SK!Ucv7O@?TW0MD@9~VfMDOw8 zJS0Nzm`y(?)x6)tt={E6jgdpW$L(%FT<(dV*lar7M3ML}D@+CCp#Mrxl=sEapP{EX zZNA;M;ef&wY&PiwQ4Z9kdc*|MnB%#(juS-05bD-tJ3I08NMmRl5%+C^G&WTc>1o^gZZnS<5@}L=q3lwa+dQ zt{HgAuMm1`C|q13-sNX6j$=*2#}Du^r$lVWPYKdoid_;TJ=1V!PRcp7GTu0}G)ep? z@W3!8x(AYQC?V);j`y|Hun&@_W37kE4FQ6CuoZ%01VuAKa0lx;4l;cH0M)n78^yvG zTJUQn{5T7qX2%j9Jk7h4Jq>=$ygOw^9^A)Ee$Wdk+x*YsrK}GM*IG1JP|&p;S}G{w zfFJD`6k`yQ(+hza6zqC3lAAWDTGZZ)_vg`umAfMzEF>-W&aR3XkuUS=fZbOiBbc0I zEG6}=?UL?MT?fua0PGkxkSmF+!B?!viWNXYGnI-=?#wI(pXf%>(4JA7Qfd7HM!^!i z7s*pjv#vpDF$WX1IHSX}ltJM}86wC(lF0kTFo}GKL@v1)Xm^Y8wy}lfF}9I&=JdHo z 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�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Ên_ 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
    >ZR_+NM&th-oye0cWJw)EvwBh8ZcvoO`{ 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 literal 0 HcmV?d00001 diff --git a/ts.tsc b/ts.tsc new file mode 100644 index 0000000..4c3dd77 --- /dev/null +++ b/ts.tsc @@ -0,0 +1,14 @@ +TILE STUDIO + +[Recent Projects] + +[Window] +X=0 +Y=0 +W=800 +H=600 + +[Settings] +Trans=$FF00FF +Replace=$FF04FF + From 47f6405ac336dc388a2b38f59f721db783189026 Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Wed, 16 Nov 2022 10:17:30 +1100 Subject: [PATCH 2/9] cmd line opperation for F10 run F10 script via cmdline and exit see main.pas search CMDLINE_OP --- Main.pas | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Main.pas b/Main.pas index a74c491..2f4cd6c 100644 --- a/Main.pas +++ b/Main.pas @@ -1001,9 +1001,9 @@ TMainForm = class(TForm) Sessions: Integer; History: string; CDROM: Boolean; - ReadParamFile: Boolean;//CMDLINE_OP + ReadParamFile: Boolean; resultCMD: Integer;//CMDLINE_OP - ReadParamCMD: string; + ReadParamCMD: string;//CMDLINE_OP RecentFiles: TStringList; WinLeft, WinTop, WinWidth, WinHeight: Integer; // 2.55 TileSelX1, TileSelY1, // 2.0 From 57e6931b85a2af8dfe8cc8266557a7320f5dec62 Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Wed, 16 Nov 2022 22:37:31 +1100 Subject: [PATCH 3/9] script !ExportDuplicateTiles Exports duplicate tiles, ie when not using tstilebitmap Updated html tutorial/help from: https://tilestudio.sourceforge.net/tutor.html and reply from https://sourceforge.net/p/tilestudio/discussion/159337/thread/c4d69307/ --- Main.pas | 50 +- Tutorial/tutor.html | 1115 +++++++++++++++++++++++++++++++++++++++++++ ts.exe | Bin 1067008 -> 1067008 bytes 3 files changed, 1142 insertions(+), 23 deletions(-) create mode 100644 Tutorial/tutor.html diff --git a/Main.pas b/Main.pas index 2f4cd6c..188f750 100644 --- a/Main.pas +++ b/Main.pas @@ -1001,9 +1001,9 @@ TMainForm = class(TForm) Sessions: Integer; History: string; CDROM: Boolean; - ReadParamFile: Boolean; - resultCMD: Integer;//CMDLINE_OP - ReadParamCMD: string;//CMDLINE_OP + ReadParamFile: Boolean;//CMDLINE_OP + resultCMD: Integer;//CMDLINE_OP + ReadParamCMD: string; RecentFiles: TStringList; WinLeft, WinTop, WinWidth, WinHeight: Integer; // 2.55 TileSelX1, TileSelY1, // 2.0 @@ -8952,7 +8952,7 @@ procedure TMainForm.Generate1Click(Sender: TObject); // options StartWithEmptyTile: Boolean; - + ExportDuplicateTiles: Boolean; // ignore unique tile check const @@ -12039,7 +12039,8 @@ procedure TMainForm.Generate1Click(Sender: TObject); StartWithEmptyTile := FALSE; - + ExportDuplicateTiles := FALSE; // ignore unique tile check + SetNumVar ('TRUE', 1); SetNumVar ('FALSE', 0); @@ -13166,29 +13167,32 @@ procedure TMainForm.Generate1Click(Sender: TObject); var i: Integer; s: string; - begin + begin for i := 0 to lines.Count - 1 do begin s := UpCaseStr (Trim(lines.Strings[i])); - if (s <> '') then - begin - if (s[1] = '!') then - begin - Delete (s, 1, 1); - - - - if (s = 'STARTWITHEMPTYTILE') then - StartWithEmptyTile := TRUE; + if (s <> '') then + begin + if (s[1] = '!') then + begin + Delete (s, 1, 1); + if (s = 'STARTWITHEMPTYTILE') then + begin + StartWithEmptyTile := TRUE; + end; + + if (s = 'EXPORTDUPLICATETILES') then + begin + ExportDuplicateTiles := TRUE; // ignore unique tile check + end; + + end; + end; - end; - end; - end; - - end; - + end; +end; { TMainForm.Generate1Click } @@ -13394,7 +13398,7 @@ procedure TMainForm.Generate1Click(Sender: TObject); for j := 0 to N - 1 do if not found then begin - diff := FALSE; + diff := ExportDuplicateTiles; // ignore unique tile check for y := 0 to tbr.H - 1 do if not diff then for x := 0 to tbr.W - 1 do diff --git a/Tutorial/tutor.html b/Tutorial/tutor.html new file mode 100644 index 0000000..be75002 --- /dev/null +++ b/Tutorial/tutor.html @@ -0,0 +1,1115 @@ + + + Tile Studio Tutorial + + + + + + + +
    +
    + + + +
    + +
    +

    + +
    + + + +

    TILE STUDIO TUTORIAL

    +     +by Mike Wiering, Wiering Software +

    + + + +
    + + +

    Contents

    +     + + + +

    When to use Tile Studio

     +     +
      + Tile Studio is a combination of a tile editor and a map + editor and was made to design games. The program was not designed + to edit large bitmaps like normal drawing programs. Tile Studio works best + with small bitmaps (tiles) from 16x16 to about 128x128 pixels. However, + larger or smaller sizes can also be used. +

      + With Tile Studio, you can only design graphics and levels, not complete + games. You will need a real programming language to write your actual + game. In order to use the graphics and levels you create, you will also + need (to create) an interface between Tile Studio and your programming + language (.tsd file). Besides, you will also need (to write) code + that can actually run your game. There are several examples of .tsd files + in the Examples section of the + Tile Studio Homepage. + +

    + + +

    Importing Tiles

    +     +
      + With Tile Studio, you can easily Import Tiles from existing .BMP or + .PNG bitmaps (File | Import Tiles). This way, you can easily reuse tiles you + made before in other programs or use tiles from screenshots of other games. + +

      +

      +Import dialog
      + + Import tiles from any .BMP bitmap + +
      +

      + + + There is an auto-detect button that can often find the size of the tiles + automatically once the transparent color has been set properly. You can set + the transparent color by clicking anywhere in the bitmap. Hold shift down to + select more than one color (as in the example). To see if your parameters + are correct, move the mouse pointer over the image and you will see the + separate tiles appear in the box at the bottom-right. +

      + Each set of tiles (called tile set here) must have a unique + identifier (name). This identifier is used when you generate code for your + game. While programming your game, you can refer to identifiers you define + here. +

      + If want to import tiles from several bitmaps, just import them one by one, + then copy all these tiles to a new tile set using the Copy Tiles + (Edit | Copy Tiles...). Finally, remove all the duplicate tiles with + Remove Duplicates from the Tile menu. +

      + If you import tiles and then modify your original bitmap, you can re-import + the tiles into your current tile set by pressing F5 (Refresh imported tiles). This only works for + the tile set you imported, not for copies of it. Be careful: all changes + you have made to your tile set after importing it the first time will be + lost! Besides, if you add tiles, remove (duplicate) tiles, move tiles in + your tile set or change the dimensions of your imported bitmap, your maps + can be screwed up! So either edit your tiles inside Tile Studio or with your + external program, but not with both! + +

    + + +

    Selecting Colors

    +     +
      + By default, Tile Studio uses a smooth RGB palette. However, by pressing + Shift-P, you can switch to a different type of palette, which contains + horizontal and vertical shades of red, green and blue. This palette may + look a bit strange, it is formed by colors that have an equal RGB distance + to each other. The order of the colors can be changed at any time + by pressing Ctrl+P (Rearrange Palette). The color depth can also + be changed from 6 to 10 with Ctrl+6, Ctrl+7, Ctrl+8, Ctrl+9 and Ctrl+0. + At depth 6, only 6x6x6=216 colors are used, making your bitmaps suitable + for 256 color mode. At any time, tiles can be matched to the current + palette (Tile | Match Colors). + +

      +

      +Palette     +Color pattern +
      + + The color palette at depth 6 (left) and a color pattern (right) + +
      +

      + + To select a color, click the palette with the left button. The selected + color is displayed in the box under the palette at the left. By clicking + in this box you can select any RGB color from a color dialog. You can + also select a color with the right mouse button. This color will then be + displayed as the transparent color. To reset it, click in the (transparent) + box at the center. +

      + Whenever you select a color (with the left mouse button) a color pattern + appears in the box at the right. If you click again without moving your + mouse pointer, the colors will slightly change. Click several times to find + the colors you need. Then you make a selection in this box to indicate + which colors you want to use. An arrow appears at the top of this box. + You can move this arrow to the left and right by pressing the keys - and =. + Most of the drawing tools can work with such color patterns. Color patterns + you have used in your tiles are saved and can be selected with [ and ]. +

      + Normally, color patterns are based on one color (from dark to light). However, + you can create a color pattern from the color you have selected to a new color + by holding shift down. +

      + When drawing, you can select a color from your bitmap by clicking with + the right button. Its also possible to get a separate palette of all the + colors used in your tiles by pressing Ctrl+U. + +

    + + + +

    The Palette Manager

    +     +
      + + Note: 256-color support coming soon +

      + + Tile Studio can be used for projects with palette based graphics. Palettes + may contain up to 256 entries. Part of a palette may be left undefined (so + you can reserve those non-preset entries for other things). + Each tile set can have it's own palette, but one palette can be used for + several tile sets. You can create palettes with the palette manager + (Ctrl+F9). You can edit each color separately and make smooth transitions + between colors (hold Shift down). But you can also import your palette, + generated it or create it from the colors you have used in your tile set + so far. + +

      +

      +Palette manager
      + + The Palette Manager + +
      +

      + + Normally, its best to create your palette after drawing your tiles. + Press Ctrl+U so you have a panel showing all the colors you have used and + then start the palette manager. When you create a new palette (New...), + it will contain the colors you have used in your tile set. However, this + only works if you haven't used more than 256 colors. If you have, set the + color depth to a lower value, for example 6 (Ctrl+6) and generate your + used colors list again (Ctrl+U). + +

    + + + +

    Drawing Tools

    +     +
      + The drawing tools are displayed at the left. Here is a description of + these drawing tools: +

      + + +

        + + + + + + + + + + + + + + + + +
        + +
        + +        		 + + Select this pencil to draw pixel by pixel no matter how thick your line + is. If a color pattern is selected, the pencil color is the last color + selected in the pattern. Drawing with the transparent color is also + possible: click the transparent color with the left mouse button. + With the Shift key down, you can erase with the right mouse button. + + + +
        + + + + + + The brush works just like the pencil, except it can be made thicker + by changing the line width. When a color pattern is selected, all lines + drawn with a brush start with the first color and end with the last. + + +
        + +
        + +        		 + + This line indicates the line width. By clicking with the left button, + the line can be made wider, clicking with the right button will make the + line narrower. This line width is used with the paint brush, lines, + rectangles, circles and round rectangles. + + +
        + + + + + + With these tools you can draw lines, rectangles, circles and round + circles. The thickness of the lines depends on the line width again. + There are also filled versions of these tools (except the line tool of course). + When a color pattern is selected, the shape is filled from the outside + to the center with colors in the pattern. Hold Shift down to only + overwrite colors that are not in the pattern or have a lower index + (try it!). You can also do a gradient fill with these tools: make sure + you have selected a pattern, then start drawing and type "h", "v" or + "d" for horizontal, vertical or diagonal. Also try holding Ctrl down + before you start drawing! + +
        + + + + + Use this tool to fill any area with the selected color. Again, this can + also be used with the transparent color. You can also fill the entire + tile or a selection by pressing F (Fill). + +
        + + + + + These are special effects that can be used in combination with the other + tools above. Whenever the "Brighten" button (with the sun) is down, + instead of drawing with the selected color, you will draw with light! + If the "Darken" button is down (the moon), everything becomes darker. + Both these buttons can be used in combination with the Alt key, which + makes the effect much smaller. The next button "Add Colors" combines the + selected color with the colors in your bitmap. You get the average of + what you draw and what was already there. Again, you can use Alt to + make the effect much smaller. You can also get these effects at real-time + (Tile | Real Time Lightening). The last button "Smooth Random Fill" + normally makes everything smoother. If you also press Shift, a little + noise is added. If a color pattern is selected, the area will be filled + with random colors from your pattern. + +
        + + + + + With this tool you can make a selection in your tile. You can then + drag your selection to a different location, copy it or (stetch) paste + into it, flip it, move pixels or match colors. +
        +
      + +
    +

    + + + +

    The Map Editor

    + +
      + + By pressing Ctrl+Tab, you can switch between the tile editor and the + map editor. A map is always based on a tile set, so you should first + create (some of) your tiles before creating a map. Each tile set can + have several maps, but each map can only use tiles from one tile set. + +

      + Please note that the Undo function is not available for the map editor + in the current version of Tile Studio. + +

      + Using the map editor, you can create a complete layer of tiles. As you + place your tiles into the map, you can mirror them horizontally and + vertically and also combine tiles to new ones. In the example below, + the grass is placed in front of the tree and the grass tile is mirrored + horizontally. + +

      +

      +Example     +Current Tile +
      + + Example of overlapping tiles (left) and the current tile (right) + +
      +

      + + Selecting tiles might require some practice. At the right of the screen, + the current tile is displayed (at the top). This is the tile you are + drawing with. The current tile actually has three layers, so three tiles + can be placed in front of each other. These are displayed from left to + right. All three of these tiles can be mirrored horizontally or + vertically. To change one of these tiles, first select the layer you want + to change (in the example above, the middle layer is selected) by pressing + the right mouse button or the Tab key, then + select a tile from your tile set. Finally, you can select the 'h' and 'v' + to mirror the tile. + + +

      + The map editor has the following drawing tools: +

      + + +

        + + + + + + + + + +
        + +
        + +        		 + When the pencil tool is selected, you can draw with the current tile. + Just hold the left mouse button down and move the mouse pointer through + the map. All three layers are completely overwritten, not only the + selected layer. + With the right mouse button, you can select a new current tile + from the map. + +
        + + + + + With this tool you can make a selection in the map. You can easily fill + a whole selection with a tile by clicking on the tile in your tile set. + By pressing Del, you can remove all tiles in the selection. Whenever you + copy a selection, it appears on the clipboard at the right, see the + image below. To unselect, press the right mouse button. + + +
        + + + + + + Use this tool if you have several small bitmaps that together form a + larger one. Select the first (top-left) tile and move the mouse pointer. + The area you select will be filled with separate tiles in the same order + as they appear in your tile set. This function works with one layer at a + time. + + +
        + + + + + + This is a normal block fill function. Just create your current tile + with three layers and use this tool to draw larger areas. All three + layers are overwritten. + + +
        +
      +

      + + You can paste areas from the clipboard into your map by first making a + selection and then pressing Ctrl+V. If your selection is too large, the + tiles will be repeated. There is also a special Stretch Paste function to + paste a block of tiles into a selection with a different size. All the + edge tiles will be placed at the edge of the new selection. + +

      +

      +Clipboard     +Stretch Paste Example +
      + + The Clipboard (left) and example of the Stretch Paste function (right) + +
      +

      + + In this example, the large wall was made by copying the small one and then + Stretch-Pasting it into a much larger selection. Another interesting function + is Random Fill (Ctrl+R). It fills the selection with random tiles from the + clipboard. + +

    +

    + + + +

    Bounds and Map Codes

    + +
      + + In Tile Studio, you can define bounds in the tile editor and in the map + editor. Bounds are "walls" in your map that indicate where objects can + move (whenever an object passes a bound, a collision occurs). Usually, + you will use bounds to indicate the ground, walls, platforms, etc. + +

      +

      +Bounds in a level     +Bounds and Map Codes +
      + + Bounds in a level + +
      +

      + + + The image above shows some bounds (the white lines). + Each tile can have upper, lower, left and right bounds set or not set. + Diagonal bounds are also possible (/ and \). + When you draw a tile that will always have the same bounds, you can + set create these bounds in the tile editor. Every time you insert this + tile in a map, these bounds are automatically set. You can also first + place a tile in your map, then select it and change the selection's + bounds. +

      + Map Codes are numbers from 1 to 255 that can be placed at any position + in the map. These numbers can be used by your game to create objects and + for other things. In the map, these codes are displayed as hexadecimal + numbers (takes less space than decimal), from 01 to FF. To change a map + code, click on the button with 00. + + +

    +

    + + + +

    Animation

    + +
      + + Tile Studio is also very useful for designing animated sprites. You can + design sprites in the same way as tiles and use several tiles for the + separate animation frames. You can even have your animation run while you + are drawing! Select the first frame with Shift+[, the last with Shift+]. + Then turn animation on (Ctrl+A) and your animation start to run. +

      + + To create animation sequences you can use in your game, you have to create + a special map for the sequence. Place all the frames in a row in this map + and add a map code to each tile, indicating the number of frames the tile + should be displayed. + + +

      +

      +Bounds in a level +
      + + Tile Sequence + +
      +

      + + The sequence above consists of two tiles, which both run for 10 (hex) + frames. You can create a Tile Sequence by selecting these tiles (two in + this example) and pressing Shift+F7 (Convert to Tile Sequence). + You will see your new tile sequence running at the bottom-right of the + screen. You can insert this tile sequence by selecting an area in the map + and pressing F7 (Insert Tile Sequence). The number of the tile sequence + is displayed in red (01 in the example). This number is actually + everything you need to be able to use the sequence in your game. So + removing the separate tiles from this map (at the left) would do no harm. + +

    + + + + +

    Importing PovRay animations

    +     +
      + + If you use PovRay to create your + animations, you can import them into Tile Studio (Animation | Import + PovRay Animation...). To do this, you must first render all the frames and + make sure you have .BMP bitmaps, with names like: Name0.bmp, Name1.bmp, + Name2.bmp, etc. Select one of these files (Open...) and wait for Tile + Studio to find the number of frames. You can choose a divide factor and + X and Y shift values to make the graphics fit into your tile set. + Warning: importing a PovRay animation clears the entire tile set. + +
    + + + + + +

    Creating a Tile Studio Definition (.tsd) file

     +     +
      + + The output Tile Studio generates is programmable and depends on the .tsd + file you use. You can edit this file in Tile Studio by pressing Shift+F10. Because this + is rather complicated, only try this if you have some programming + experience. +

      + The .tsd files are meant as source code which you can import directly into + your game source. A very simple .tsd file could look like this: + +

      +    ; My first Tile Studio Definition file
+    #file c:\\hello.txt
+    Hello, world!
+    #end file
+
      + + This is just to give you an idea how it works, it isn't very useful at + all. Every type you press F10 (Generate Code), the file + c:\hello.txt is + created with the text "Hello, world!". Note that + \\ is converted to \. + In the same way, \n can be used for a new line. + All commands are preceded by a # and comment + lines start with a ;. + Everything you place between #file + and #end file will be written to + the file. +

      + + There are several variables, known by Tile Studio, which can be placed + between < and >. + These will be interpreted as the information is written to the file. + +

      +    ; create the graphics files
+    #tileset
+    #tilebitmap <TileSetIdentifier>.BMP
+    #end tilebitmap
+    #end tileset
+    
+    ; Pascal procedure to check if all graphics files exist
+    #file CHECKBMP.INC
+      procedure CheckBMPFiles;
+      begin
+    #tileset
+        if not Exists ('<TileSetIdentifier>.BMP') then
+          Error ('Cannot find <TileSetIdentifier>.BMP');
+    #end tileset
+      end;
+    #end file
+
      + + This example is a little more complicated. First it goes through all the + tile sets you have created (#tileset ... + #end tileset). The command + #tilebitmap makes Tile Studio create a bitmap + containing all the tiles + you have used in your maps (24-bit BMP only). Here, we use the name + <TileSetIdentifier>.BMP. Here, + TileSetIdentifier is a variable, + which is replaced by the names you gave to your tile sets. Suppose you + have two tile sets, named Tiles1 and Tiles2, + then two bitmaps would be created, named Tiles1.BMP and + Tiles2.BMP. +

      + In the example, a file is written named CHECKBMP.INC, containing a + Pascal procedure that checks the existence of all the graphics files. + If you had the two tile sets Tiles1 and Tiles2 again, + you would get the following file, which could be included into a + Pascal program. + +

      +    procedure CheckBMPFiles;
+    begin
+      if not Exists ('Tiles1.BMP') then
+        Error ('Cannot find Tiles1.BMP');
+      if not Exists ('Tiles2.BMP') then
+        Error ('Cannot find Tiles2.BMP');
+    end;
+
      + + + Below is the complete list of variables and commands you can use in + a .tsd file. The syntax of all commands is + #command ... #end command, + some commands have optional parameters. +

      + The variables are usually only available within a certain scope, defined + by a command. For example, FrameCount, can only be + used between #sequencedata and #end + sequencedata. +

      + You can print a variable in a special way by adding a colon and a format + string to a variable. For example: + <BoundMapValue:"%4xH"> would print the variable + BoundMapValue as a 4-digit hexadecimal value followed + by the letter H. +

      + You can even write complete numeric expressions between the < and + >, these are evaluated by Tile Studio, for example + <TileHeight - Overlap>. Normally, this feature isn't + really necessary, since your compiler is probably capable of calculating + <TileHeight> - <Overlap>. + However, it can make your final output file a lot smaller and more readable, like in the following example: + <(R shr 2)+(G shr 2)*0x100+(B shr 2)*0x10000:"0%06xh">. + +

      + + +

        +#file FileName - Command to start writing to an output file (text)
        +#binfile FileName DefaultBitSize - Command to start writing a binary file
        +ProjectName - Name of your Tile Studio project file (without .tsp)
        +Author - Project information: author
        +Notes - Project information: notes
        +Copyright - Project information: copyright notice
        +OutputDir - Current ouput directory
        +CurrentDate - Current date
        +CurrentTime - Current time
        +TSVersion - Version of Tile Studio
        +#readtextfile FileName [begin] [separator] [long-line] [end] - Command to go through the lines of a text file
        +
          + TextFileLine - The current line from the file as a string
          + TextFileLineValue - The current line as an integer number if valid
          + LineNumber - Line number in the file (0, 1, 2, ...)
          +
        +#readbinfile FileName [begin] [separator] [long-line] [end] - Command to go through the bytes of a binary file
        +
          + BinFileChar - The current byte as a character
          + BinFileByte - The current byte as an ASCII number
          + BinFilePos - The position in the file (0, 1, 2, ...)
          +
        +#list ListName [begin] [separator] [end] - Command to go through the list ListName
        +
          + #list ListName [begin] [separator] [end] - You can use lists recursively
          + Item - The current item of the list as a string (if recursive: ListNameItem0, 1, 2, ...)
          + ItemValue - The current item as an integer number if valid (if recursive: ListNameItemValue0, 1, 2, ...)
          + Index - The position in the list (0, 1, 2, ...) (if recursive: ListNameItemIndex0, 1, 2, ...)
          +
        + +PaletteCount - Total number of palettes
        +#palette [separator] - Command to go through all the palettes
        +
          + PaletteIdentifier - The identifier of the current palette
          + PaletteNumber - The number of the current palette (0, 1, 2, ...)
          + PaletteSize - The total number of entries in the palette
          + PalettePreset - Number of colors defined in the palette
          + #palettedata [begin] [separator] [end] - Command to go through all the palette entries
          +
            + Index - Current index number
            + RGB - RGB color value of palette entry
            + R - Color value for red (0..255)
            + G - Color value for green
            + B - Color value for blue
            +
          +
        +TileSetCount - Total number of tile sets
        +#tileset [separator] - Command to go through all the tile sets
        +
          + #tilebitmap FileName [MaxWidth] - Creates .BMP or .PNG image with all tile combinations in your maps
          + #tstilebitmap FileName [MaxWidth] - Creates .BMP or .PNG image with the exact tiles in your tile set
          + TileSetIdentifier - The identifier of the current tile set
          + TileSetNumber - The number of the current tile set (0, 1, 2, ...)
          + TileWidth - Tile width in pixels
          + TileHeight - Tile height in pixels
          + HorizontalTileCount - Number of tiles horizontally
          + VerticalTileCount - Number of tiles vertically
          + TileSetBitmapWidth - Total bitmap width
          + TileSetBitmapHeight - Total bitmap height
          + TransparentPosX - X-position of a transparent pixel
          + TransparentPosY - Y-position of a transparent pixel
          + TransparentColorR - Transparent color value for red (0..255)
          + TransparentColorG - Transparent color value for green
          + TransparentColorB - Transparent color value for blue
          + Overlap - Height of vertical overlapping area
          + BackgroundColorR - Background color value for red (0..255)
          + BackgroundColorG - Background color value for green
          + BackgroundColorB - Background color value for blue
          + PaletteIdentifier - The identifier of the current palette
          + PaletteNumber - The number of the current palette (0, 1, 2, ...)
          + PaletteSize - The total number of entries in the palette
          + PalettePreset - Number of colors defined in the palette
          + #palettedata [begin] [separator] [end] - Command to go through all the palette entries
          +
            + Index - Current index number
            + RGB - RGB color value of palette entry
            + R - Color value for red (0..255)
            + G - Color value for green
            + B - Color value for blue
            +
          + TSTileCount - Total number of actual tiles in your tile set
          + #tstile [separator] - Command to go through all the tiles in your tile set
          +
            + TileNumber - Number of the current tile (0, 1, 2, ...)
            + #tilemap [begin] [separator] [long-line] [next-row] [end] - Map of tinytiles that form the current tile
            +
              + TinyTileNumber - Tinytile index number
              + X - Horizontal tinytile counter
              + Y - Vertical tinytile counter
              +
            + #tiledata [begin] [separator] [long-line] [next-row] [end] [transparent] - Command to go through the pixels of the current tile
            +
              + X - Current X-position within the tile
              + Y - Current Y-position within the tile
              + Pixel - Index number of closest color in palette
              + RGB - RGB color value of current pixel
              + R - Color value for red (0..255)
              + G - Color value for green
              + B - Color value for blue
              + A - Alpha value (0..255)
              +
            +
          + TileCount - Total number of tile combinations in your map(s)
          + #tile [separator] - Command to go through all the separate tile combinations
          +
            + TileNumber - Number of the current tile (0, 1, 2, ...)
            + #tilemap [begin] [separator] [long-line] [next-row] [end] - Map of tinytiles that form the current tile
            +
              + TinyTileNumber - Tinytile index number
              + X - Horizontal tinytile counter
              + Y - Vertical tinytile counter
              +
            + #tiledata [begin] [separator] [long-line] [next-row] [end] [transparent] - Command to go through the pixels of the current tile
            +
              + X - Current X-position within the tile
              + Y - Current Y-position within the tile
              + Pixel - Index number of closest color in palette
              + RGB - RGB color value of current pixel
              + R - Color value for red (0..255)
              + G - Color value for green
              + B - Color value for blue
              + A - Alpha value (0..255)
              +
            + #textiledata [begin] [separator] [long-line] [next-row] [end] [transparent] - Generate texture tiles (with extra edge pixels)
            +
              + X - Current X-position within the tile
              + Y - Current Y-position within the tile
              + Pixel - Index number of closest color in palette
              + RGB - RGB color value of current pixel
              + R - Color value for red (0..255)
              + G - Color value for green
              + B - Color value for blue
              + A - Alpha value (0..255)
              +
            + OtherTopLeftCorners - If 1, the top left corner can be different
            + OtherTopEdges - If 1, the top edge of this tile can be different
            + OtherTopRightCorners - If 1, the top right corner can be different
            + OtherLeftEdges - If 1, the left edge of this tile can be different
            + OtherRightEdges - If 1, the right edge of this tile can be different
            + OtherBottomLeftCorners - If 1, the bottom left corner can be different
            + OtherBottomEdges - If 1, the bottom edge of this tile can be different
            + OtherBottomRightCorners - If 1, the bottom right corner can be different
            + #tilebitmap FileName - Creates .BMP or .PNG image of the current tile
            + #tstilebitmap FileName - Creates .BMP or .PNG image of the current tile
            +
          + UniequeTexTileCount - Number of unique tile combinations with edges and corners
          + #uniquetextile [separator] - Generates all unique tile combinations with edges and corners
          +
            + TileNumber - Number of the current tile (0, 1, 2, ...)
            + #tiledata - Command to go through the pixels of the current tile
            +
          + #tile0 - Special command to get the properties of the empty tile
          +
            + OtherTopLeftCorners - If 1, the top left corner can be different
            + OtherTopEdges - If 1, the top edge of this tile can be different
            + OtherTopRightCorners - If 1, the top right corner can be different
            + OtherLeftEdges - If 1, the left edge of this tile can be different
            + OtherRightEdges - If 1, the right edge of this tile can be different
            + OtherBottomLeftCorners - If 1, the bottom left corner can be different
            + OtherBottomEdges - If 1, the bottom edge of this tile can be different
            + OtherBottomRightCorners - If 1, the bottom right corner can be different
            +
          + HEdgeCount - Number of horizontal edges (textiles)
          + #hedge [separator] - Combinations of tiles that have different horizontal edges
          +
            + HEdgeNumber - Number (0, 1, 2, ...)
            + TopTile - Upper tile
            + BottomTile - Lower tile
            + #hedgedata [begin] [separator] [long-line] [next-row] [end] [transparent] - The horizontal edges (two pixels high)
            +
              + See #tiledata
              +
            +
          + VEdgeCount - Number of vertical edges (textiles)
          + #vedge [separator] - Combinations of tiles that have different vertical edges
          +
            + VEdgeNumber - Number (0, 1, 2, ...)
            + LeftTile - Left tile
            + RightTile - Right tile
            + #vedgedata [begin] [separator] [long-line] [next-row] [end] [transparent] - The vertical edges (two pixels wide)
            +
              + See #tiledata
              +
            +
          + CornerCount - Number of corners (textiles)
          + #corner [separator] - List of tile combinations that require corners to be redrawn
          +
            + CornerNumber - Number (0, 1, 2, ...)
            + TopLeftTile - Top left tile
            + TopRightTile - Top right tile
            + BottomLeftTile - Bottom left tile
            + BottomRightTile - Bottom right tile
            + #cornerdata [begin] [separator] [end] [transparent] - The corner tiles (all 2 x 2 pixels)
            +
              + See #tiledata
              +
            +
          + SequenceCount - Number of sequences defined
          + #sequence [separator] - Command to go through all the sequences
          +
            + SpriteName - Name of sprite (if sprite has its own map)
            + SpriteNumber - Number of the sprite (0, 1, 2, ...)
            + SpriteLength - Number of frames
            + SequenceNumber - Number of the sequence (1, 2, 3, ...)
            + SequenceLength - Number of frames
            + #sequencedata [begin] [separator] [end] - Command to go through all the frames (tile by tile)
            +
              + Frame - Index (0, 1, 2, ...)
              + FrameCount - Duration of the tile in the sequence
              + TileNumber - Number of the tile in the bitmap
              + TileNumberLoByte - Tile combination number mod 256
              + TileNumberHiByte - Tile combination number div 256
              + Bounds - Bounds (see table below)
              + TSBackTile - Number of the tile in your tile set (back layer)
              + TSMidTile - Number of the tile in your tile set (middle layer)
              + TSFrontTile - Number of the tile in your tile set (front layer)
              + TSBackHF - Horizontal flip (back layer): 0 or 1
              + TSMidHF - Horizontal flip (middle layer)
              + TSFrontHF - Horizontal flip (front layer)
              + TSBackVF - Vertical flip (back layer): 0 or 1
              + TSMidVF - Vertical flip (middle layer)
              + TSFrontVF - Vertical flip (front layer)
              + TSBackR - Rotate 90 degrees right (back layer): 0 or 1
              + TSMidR - Rotate 90 degrees right (middle layer)
              + TSFrontR - Rotate 90 degrees right (front layer)
              + OffsetX - X-Offset of the tile
              + OffsetY - Y-Offset of the tile
              +
            +
          + #sequenceframe [begin] [separator] [end] - Same as #sequence, but repeats for every frame of the sequence separately
          + MapCount - Number of maps that belong to the current bitmap
          + #map [separator] - Command to go through all the maps
          +
            + MapIdentifier - Identifier of the map
            + MapNumber - Number of the map (0, 1, 2, ...)
            + MapWidth - Number of tiles horizontally
            + MapHeight - Number of tiles vertically
            + ScrollX - Map scroll function X value
            + ScrollY - Map scroll function Y value
            + #mapdata [begin] [separator] [long-line] [next-row] [end] - Command to go through all the map cells
            +
              + X - Current X-position within the map
              + Y - Current Y-position within the map
              + TileNumber - Number of the tile combination
              + TileNumberLoByte - Tile combination number mod 256
              + TileNumberHiByte - Tile combination number div 256
              + Bounds - Bounds (see table below)
              + MapCode - Map code value (0..255)
              + BoundMapValue - bit 0..7: Bounds, bit 8..15: Map code
              + TSBackTile - Number of the tile in your tile set (back layer)
              + TSMidTile - Number of the tile in your tile set (middle layer)
              + TSFrontTile - Number of the tile in your tile set (front layer)
              + TSBackHF - Horizontal flip (back layer): 0 or 1
              + TSMidHF - Horizontal flip (middle layer)
              + TSFrontHF - Horizontal flip (front layer)
              + TSBackVF - Vertical flip (back layer): 0 or 1
              + TSMidVF - Vertical flip (middle layer)
              + TSFrontVF - Vertical flip (front layer)
              + TSBackR - Rotate 90 degrees right (back layer): 0 or 1
              + TSMidR - Rotate 90 degrees right (middle layer)
              + TSFrontR - Rotate 90 degrees right (front layer)
              +
            +
          + #tinytiles Width Height - Split all tiles and maps into smaller tiles
          +
        +
      + +

      +How to interpret the Bounds byte:

      +

        + Bit 7 = 0:
        +
          + Bit 0: Upper bound
          + Bit 1: Left bound
          + Bit 2: Lower bound
          + Bit 3: Right bound +
        + + Bit 7 = 1:
        +
          + Bit 0: Diagonal direction: 0=/, 1=\
          + Bit 6..1: +
            + 0: y = x
            + Not (yet) implemented:
            + 1: y = 2 * x
            + 2: y = 2 * (x + 1/2)
            + 3: y = x / 2
            + 4: y = x / 2 + 1/2

            + +

          +
        + +
      + + +
    + + +

    Generating Code

     +     +
      + + Before you can generate code for your game, you must select the Tile Studio + Definition file you want to use (Shift+F10) and also select an output + directory. This is where the output files will be placed. + Then press F10 and your code will be generated. Switch to your favorite + programming environment and finish your game! + + +
    + + + + + + + + +

    +     +
      + + + +
    + + +

    +     + +
    + + + +
    +
+The easies way is to look in the source code. 
+Here is a copy of a table with all commands/parameters (and below is the meaning of the letters FBSLNET):
+
+        ( KeyWord: 'FILE';          Parameters: 'F';       ReqCmd: [];                  idx: nil;           NewLine: FALSE; ),
+        ( KeyWord: 'BINFILE';       Parameters: 'FW';      ReqCmd: [];                  idx: nil;           NewLine: FALSE; ),
+        ( KeyWord: 'TILESET';       Parameters: 'S';       ReqCmd: [];                  idx: @itab;         NewLine: TRUE; ),
+        ( KeyWord: 'TILE';          Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @itile;        NewLine: TRUE; ),
+        ( KeyWord: 'TSTILE';        Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @itstile;      NewLine: TRUE; ),
+        ( KeyWord: 'TINYTILES';     Parameters: 'WH';      ReqCmd: [ctTileSet];         idx: nil;           NewLine: FALSE; ),
+        ( KeyWord: 'TILEDATA';      Parameters: 'BSLNET';  ReqCmd: [ctTile, ctTSTile];  idx: @idat;         NewLine: FALSE; ),
+        ( KeyWord: 'TEXTILEDATA';   Parameters: 'BSLNET';  ReqCmd: [ctTile, ctUTTile];  idx: @idat;         NewLine: FALSE; ),
+        ( KeyWord: 'MAP';           Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @imap;         NewLine: TRUE; ),
+        ( KeyWord: 'MAPDATA';       Parameters: 'BSLNE';   ReqCmd: [ctMap];             idx: @idat;         NewLine: FALSE; ),
+        ( KeyWord: 'PALETTE';       Parameters: 'S';       ReqCmd: [];                  idx: @ipal;         NewLine: TRUE; ),
+        ( KeyWord: 'PALETTEDATA';   Parameters: 'BSE';     ReqCmd: [ctPalette];         idx: @ipaldat;      NewLine: FALSE; ),
+        ( KeyWord: 'SEQUENCE';      Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @iseq;         NewLine: TRUE; ),
+        ( KeyWord: 'SEQUENCEDATA';  Parameters: 'BSE';     ReqCmd: [ctSequence];        idx: @iseqdat;      NewLine: FALSE; ),
+        ( KeyWord: 'CORNER';        Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @icorner;      NewLine: TRUE; ),
+        ( KeyWord: 'CORNERDATA';    Parameters: 'BSET';    ReqCmd: [ctCorner];          idx: @icornerdat;   NewLine: FALSE; ),
+        ( KeyWord: 'HEDGE';         Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @ihedge;       NewLine: TRUE; ),
+        ( KeyWord: 'HEDGEDATA';     Parameters: 'BSLNET';  ReqCmd: [ctHEdge];           idx: @ihedgedat;    NewLine: FALSE; ),
+        ( KeyWord: 'VEDGE';         Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @ivedge;       NewLine: TRUE; ),
+        ( KeyWord: 'VEDGEDATA';     Parameters: 'BSLNET';  ReqCmd: [ctVEdge];           idx: @ivedgedat;    NewLine: FALSE; ),
+        ( KeyWord: 'TILEMAP';       Parameters: 'BSLNE';   ReqCmd: [ctTile, ctTSTile];  idx: @itilemap;     NewLine: FALSE; ),
+        ( KeyWord: 'TILE0';         Parameters: '';        ReqCmd: [ctTileSet];         idx: @itile0;       NewLine: TRUE; ),
+        ( KeyWord: 'UNIQUETEXTILE'; Parameters: 'S';       ReqCmd: [ctTileSet];         idx: @iutt;         NewLine: TRUE; )
+
+		'W':Width
+		'H': Hieght
+
+		'F': Filename;
+		'B': Begin;
+		'S': Separator;
+		'L': Long Line Separator;
+		'N': Next Separator;
+		'E': End;
+		'T': Transparent value;
+  
+
+
+!StartWithEmptyTile -  inserts empty tile at the start of the export image, to align with the  starting from 1 not 0
+!ExportDuplicateTiles -  exports duplicate tiles, ie when not using tstilemap
+
+
    + + +
      + + + +
    + + + + +
    +
    + + Return to Tile Studio Homepage
    +     +
    + +
    +
    +
    + + + + diff --git a/ts.exe b/ts.exe index bdaf7f86376ecc4e667c51b2a51eef7f8f183a5c..7de7c9d2eb5131eec9886a5eb0466d1dd7efe520 100644 GIT binary patch delta 33243 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 delta 33051 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 Date: Wed, 16 Nov 2022 22:38:47 +1100 Subject: [PATCH 4/9] Update tutor.html --- Tutorial/tutor.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tutorial/tutor.html b/Tutorial/tutor.html index be75002..b1b2510 100644 --- a/Tutorial/tutor.html +++ b/Tutorial/tutor.html @@ -1083,7 +1083,7 @@

    !StartWithEmptyTile - inserts empty tile at the start of the export image, to align with the starting from 1 not 0 -!ExportDuplicateTiles - exports duplicate tiles, ie when not using tstilemap +!ExportDuplicateTiles - exports duplicate tiles, ie when not using tstilebitmap From f68c279059e9c61ae1f70271a42c41de3f4fea87 Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Thu, 17 Nov 2022 11:23:26 +1100 Subject: [PATCH 5/9] !RunCMDLine run cmd after script finished CMDLine - run a command line executable after the export script has finished, put command on following line, ie: #end file ; -------------------------------------------------------- !RunCMDLine ;"C:\Users\My Name\Desktop\My Project\convert.bat" "C:\Documents and Settings\My Name\Desktop\My Art\file01.png" true Tips: 0) Path and command must be full qualified and in quotes on the next line, with the first character skipped 1) Execution directory is where the excitable is launched from (where your ts.exe is, ie C:\ts\) not your project folder 2) If you use a batch file, the first command should be a cd command into your project folder, put pause to debug it etc 3) if the cmd box flashes and does nothing, it's most likely your paths are wrong, test first on the command line. --- Main.pas | 52 +- Main.pas.bak | 16982 ++++++++++++++++++++++++++++++++++++++++++ Main.~pas | 122 +- Tutorial/tutor.html | 20 +- ts.exe | Bin 1067008 -> 1067520 bytes 5 files changed, 17133 insertions(+), 43 deletions(-) create mode 100644 Main.pas.bak diff --git a/Main.pas b/Main.pas index 188f750..30a494c 100644 --- a/Main.pas +++ b/Main.pas @@ -8954,6 +8954,7 @@ procedure TMainForm.Generate1Click(Sender: TObject); StartWithEmptyTile: Boolean; ExportDuplicateTiles: Boolean; // ignore unique tile check + RunCMDLine: string; // run command line const MAX_COUNTER = 100; @@ -13176,8 +13177,14 @@ procedure TMainForm.Generate1Click(Sender: TObject); begin if (s[1] = '!') then begin - Delete (s, 1, 1); + Delete (s, 1, 1); + if (s = 'RUNCMDLINE') then // run command line + begin + RunCMDLine := UpCaseStr (Trim(lines.Strings[i+1])); // read next line + Delete (RunCMDLine, 1, 1); // remove first char + end; + if (s = 'STARTWITHEMPTYTILE') then begin StartWithEmptyTile := TRUE; @@ -13187,6 +13194,8 @@ procedure TMainForm.Generate1Click(Sender: TObject); begin ExportDuplicateTiles := TRUE; // ignore unique tile check end; + + end; end; @@ -13194,6 +13203,38 @@ procedure TMainForm.Generate1Click(Sender: TObject); end; end; + +// from https://stackoverflow.com/questions/32211723/why-delphi-app-cant-run-a-bat-file-and-make-it-work?noredirect=1&lq=1 +procedure StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); +var + StartInfo: TStartupInfo; + ProcInfo: TProcessInformation; +begin + //Simple wrapper for the CreateProcess command + //returns the process id of the started process. + FillChar(StartInfo,SizeOf(TStartupInfo),#0); + FillChar(ProcInfo,SizeOf(TProcessInformation),#0); + StartInfo.cb := SizeOf(TStartupInfo); + + if not(ShowWindow) then begin + StartInfo.dwFlags := STARTF_USESHOWWINDOW; + StartInfo.wShowWindow := SW_HIDE; + end; + + CreateProcess(nil,PChar(ExeName + ' ' + CmdLineArgs),nil,nil,False, + CREATE_NEW_PROCESS_GROUP + NORMAL_PRIORITY_CLASS,nil,nil,StartInfo, + ProcInfo); + + //Result := ProcInfo.dwProcessId; + + if WaitForFinish then begin + WaitForSingleObject(ProcInfo.hProcess,Infinite); + end; + + //close process & thread handles + CloseHandle(ProcInfo.hProcess); + CloseHandle(ProcInfo.hThread); +end; { TMainForm.Generate1Click } @@ -13684,7 +13725,14 @@ procedure TMainForm.Generate1Click(Sender: TObject); ErrMsg := RunCode; - + // run cmd line if not empty and no errors + if (RunCMDLine <> '') AND (ErrMsg = '') then + begin + // StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); + StartProcess('cmd.exe', '/C ' + RunCMDLine, TRUE, FALSE); // execute, show window and wait? + end; + + for itab := 0 to Tab.Tabs.Count - 1 do with TileTab[itab].tbr do begin diff --git a/Main.pas.bak b/Main.pas.bak new file mode 100644 index 0000000..2671ccc --- /dev/null +++ b/Main.pas.bak @@ -0,0 +1,16982 @@ +unit Main; + + { + TILE STUDIO - http://tilestudio.sourceforge.net/ + + Copyright (c) 2000-2017, Mike Wiering, Wiering Software + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + } + + + { + + To do: + + - 256 colors + + - variable tile sizes (for fonts)? + - font generator + - flag bits + - diagonal bounds (y=x/2 and y=2x) + - automatically detect mirror / upsidedown /rotate (#tile command) + - alpha layer in map editor + - update documentation and add more images + + + to do: update html tutorial: + - sequencedata --> bounds ??? + + + + History: + + - added: 'remove duplicate tiles' option for import tiles to avoid 'too many tiles' error + - fixed: paste button was often disabled when trying to copy from external source + - fixed: when removing an animation sequence, the numbers of the others in the maps are now properly lowered + + + Version 3.0 + + - select next/previous clips with Ctrl+Shift+Alt Left/Right + - added Tile->Replace color under cursor (Ctrl+R) + - added (simple) onion skinning: show a vague image of a different tile while drawing a tile, + right-click on other tile (at the bottom) + - added 'text' quotes also allowed for strings in addition to "text", useful for '"' + - added option !StartWithEmptyTile + - added opacity slider (for most drawing tools) + - fixed import palette + - 256-color palette DEFAULT.PAL (F8 to switch) + - added .. + - changed PNG unit to PNGImage ??? + - RGB conversion scripts + + - #readtextfile (, , ) + - #readbinfile (, , ) + - project lists / #list <(Name)Item/Value(n)> + - added history panel for coordinates + - added (limited) .PCX support + - added , , + and in case there are no maps (now refer to last #tstilebitmap) + - added Replace Current Tile Sequence (Ctrl+Shift+F7) + - added #sequenceframe ... #end sequencframe: same as #sequencedata, but goes through + each frame n+1 times (where n is the duration of each frame) + + + + Version 2.55 + + - fixed: Edit, Replace Colors, Replace All was replacing complete tiles + - added: Quick keys 0-9 for tools + - starting a new selection in the map doesn't change the bounds anymore + - sequences can have bounds + - #sequencedata .. #end sequencedata can now contain variable + (the bounds of the tiles used to make the sequence) + - fixed + - fixed: config file not loaded when starting from other directory + - transparent color can be changed by editing the config file TS.TSC + - paste images half size + - fixed bug introduced in 2.54: #bitmapfile didn't use target directory + + + Version 2.54 + + - export separate tiles with #TILEBITMAP or #TSTILEBITMAP + - #file ...\\... now creates path + - Replace Colors - OtherFromToList + - fixed range check error when placing mirrored tile in map with 1234 tool + - View menu: show back/mid/front layer + - copy current tile combination to clipboard (to paste as new tile) + - TilesetBitmapWidth and TilesetBitmapHeight are updated directly after #TilesetBitmap + - Map grid guidelines + + + Version 2.53 + + - fixed: move tile left/right (range check error) + - added: scale down factor 1/2/4/8 for export map as image + - added: smart pattern selection / pick up pattern (Alt + RMB) + - fixed: delete tile messed up bounds + - fixed: included maps that weren't exported + - added: , , tile 0 = 1 + - fixed: TileData: N parameter - check for compatibility! + - fixed: progressbar during generate code works better now + + + Version 2.52 + + - added: replace tiles in map + - added: replace color in tile: Ctrl + fill tool + + + Version 2.51 + + - added: tile grid (Ctrl+G to enable/disable) + - fixed: exporting map as image would only export the visible region + - added: pick up several colors to make a color pattern (Ctrl + right click) + - added: used color palette shows RGB values when moving the mouse + + + Version 2.5 + - .tsd file in project directory + - added #TSTILEBITMAP keyword + - fixed access violation error (drawing small maps with overlap > 0) + - #uniquetextile + - export complete maps as images + - right-click in map selects tile + - lighting direction can be selected (shift+left mouse button on bound box) + - binary output files: #BINFILE + - tile rotation in maps (TSBackR, TSMidR, TSFrontR) + - rotate tiles right/left (tile editor) + - hide tile set panel + - show selection size in status bar + - scale down tilesets while generating code (anti-aliasing) + + + + 2.44 and before: see website + + Modified by Rainer Deyke (rainerd@eldwood.com) // 2.42 + + } + + {$I SETTINGS.INC} + + { PNG is now handled by PngImage instead of PngUnit } + + +interface + +uses + Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, + Menus, ExtCtrls, ComCtrls, StdCtrls, Grids, jpeg, ToolWin, Buttons, Tiles, + ExtDlgs, ShellAPI, ImgList, Spin, Math, Noise, SZPCX; + +const + APPL_NAME = 'Tile Studio'; + ApplPath: string = ''; + VERSION_NUMBER: string = '3.0'; + DEFAULT_NAME = 'Untitled'; + DEFAULT_EXT = '.tsp'; + URL = 'http://tilestudio.sourceforge.net/'; + OutputPath: string = ''; + pfMap = pf16bit; + pfFinal = pf24bit; + pfOutput = pf24bit; + CONFIG_FILE = 'ts.tsc'; +{$IFDEF CREATE_BACKUP_FILES} + BACKUP_EXT = '.$$$'; +{$ENDIF} + DEFAULT_PAL = 'default.pal'; + RGBCONV_FILE = 'rgbconv.txt'; + +const + Filename: string = ''; + FileToOpen: string = ''; + +const + MAX_PALETTE_ORDER = 6; + MAX_FROM_TO = 9; + DEFAULT_COLOR = $676767; + DEFAULT_BACKGR_COLOR = $AAAAAA; + BORDER_W = 5; + BORDER_H = 5; + DEFAULT_SCALE = 8; + MAX_SCALE = 16; + MAX_UNDO = 50; + DEFAULT_CURSOR_SIZE = 4; + MAX_ZOOM = 9; + ZOOM_FACTOR = 3; + DEFAULT_ANIMATION_SPEED = 500; + DEFAULT_SEQ_SPEED = 25; + LONG_LINE = 74; + +type + TileTabRec = + record + tbr: TileBitmapRec; + id: string; + lastscrollpos: Integer; + lastscale: Integer; + + AnimStart, AnimEnd: Integer; + BackGrColor: Integer; + end; + +type + UndoRec = + record + ActionName: string; + Bmp: TBitmap; + HistoryCoords: string; // 3.00 + end; + +type + TFromToList = array[0..MAX_FROM_TO - 1] of Integer; + TExFromToList = array[0..MAX_FROM_TO - 1, 0..2] of Integer; + +type + FTSaveRec = + record + FT: TFromToList; + EXFT: TExFromToList; + F, L: Integer; + + end; + +type + TEditorMode = (mTile, mMap); + +type + TDrawingTool = (dtPoint, + dtBrush, + dtLine, + dtRect, + dtRoundRect, + dtEllipse, + dtFill, + dtFilledRect, + dtFilledRoundRect, + dtFilledEllipse, + dtSelection); + + TMapDrawingTool = (mdtPoint, mdtFilledRect, + mdtZOrder, mdtRect); + +const + FirstSaveUndoTools = [dtPoint, dtBrush, dtFill]; + +function WithoutExt (Name: string; Ext: string): string; + +type + TMainForm = class(TForm) + TilePanel: TPanel; + RightPanel: TPanel; + MainMenu: TMainMenu; + File1: TMenuItem; + NewGame1: TMenuItem; + N2: TMenuItem; + Open1: TMenuItem; + Save1: TMenuItem; + SaveAs1: TMenuItem; + N1: TMenuItem; + Exit1: TMenuItem; + Edit1: TMenuItem; + Undo1: TMenuItem; + N3: TMenuItem; + Cut1: TMenuItem; + Copy1: TMenuItem; + Paste1: TMenuItem; + Delete1: TMenuItem; + View1: TMenuItem; + RearrangePalette1: TMenuItem; + ScrollBox: TScrollBox; + PalettePanel: TPanel; + ColorsPanel: TPanel; + Palette: TPaintBox; + ColorPanel: TPanel; + BackgroundPanel: TPanel; + FromToPanel: TPanel; + Color: TShape; + Background: TShape; + FromTo: TPaintBox; + ZoomIn1: TMenuItem; + ZoomOut1: TMenuItem; + Tile: TImage; + Toolbar: TToolBar; + Move1: TMenuItem; + Up1: TMenuItem; + Down1: TMenuItem; + Left1: TMenuItem; + Right1: TMenuItem; + Tile1: TMenuItem; + Flip1: TMenuItem; + Horizontal1: TMenuItem; + Vertical1: TMenuItem; + Clear1: TMenuItem; + PatternPanel: TPanel; + N5: TMenuItem; + Pattern1: TMenuItem; + Pattern: TImage; + N6: TMenuItem; + ImportTiles1: TMenuItem; + ExportTiles1: TMenuItem; + OpenPictureDialog: TOpenPictureDialog; + NewTile1: TMenuItem; + MatchColors1: TMenuItem; + Help1: TMenuItem; + About1: TMenuItem; + Redo1: TMenuItem; + N8: TMenuItem; + MoveTile1: TMenuItem; + MoveTileLeft: TMenuItem; + MoveTileRight: TMenuItem; + N9: TMenuItem; + RemoveDuplicateTiles1: TMenuItem; + Homepage1: TMenuItem; + N10: TMenuItem; + SavePictureDialog: TSavePictureDialog; + SetBounds1: TMenuItem; + Left2: TMenuItem; + Right2: TMenuItem; + Top1: TMenuItem; + Bottom1: TMenuItem; + N13: TMenuItem; + DiagonalUp1: TMenuItem; + DiagonalDown1: TMenuItem; + N12: TMenuItem; + ClearAll1: TMenuItem; + NewTileSet1: TMenuItem; + Map1: TMenuItem; + N11: TMenuItem; + Properties1: TMenuItem; + ProgressPanel: TPanel; + ProgressBar: TProgressBar; + Toolbar1: TMenuItem; + ImageList: TImageList; + NewButton: TToolButton; + OpenButton: TToolButton; + SaveButton: TToolButton; + ToolButton1: TToolButton; + CutButton: TToolButton; + CopyButton: TToolButton; + PasteButton: TToolButton; + ToolButton2: TToolButton; + UndoButton: TToolButton; + RedoButton: TToolButton; + DeleteButton: TToolButton; + ToolButton3: TToolButton; + Zoom1: TMenuItem; + ZoomButton: TToolButton; + ActualSize1: TMenuItem; + FitinWindow1: TMenuItem; + RGBColorDepth1: TMenuItem; + N61: TMenuItem; + N71: TMenuItem; + N81: TMenuItem; + N91: TMenuItem; + StatusBar: TStatusBar; + Tab: TTabControl; + TileScrollBox: TScrollBox; + TileBitmap: TImage; + ZoomInButton: TToolButton; + ZoomOutButton: TToolButton; + DuplicateTile1: TMenuItem; + N101: TMenuItem; + Palette1: TMenuItem; + N4: TMenuItem; + ColorBrightness1: TMenuItem; + N_1: TMenuItem; + N_2: TMenuItem; + N_3: TMenuItem; + N_4: TMenuItem; + N_5: TMenuItem; + N_6: TMenuItem; + N_7: TMenuItem; + N_8: TMenuItem; + N_9: TMenuItem; + ToolButton7: TToolButton; + NewTileButton: TToolButton; + ColorMatchButton: TToolButton; + ToolButton4: TToolButton; + ColorDialog: TColorDialog; + N14: TMenuItem; + Map2: TMenuItem; + BackgroundColor1: TMenuItem; + N15: TMenuItem; + CursorImage: TImage; + CurTilePanel: TPanel; + TilePartsPanel: TPanel; + CopyTiles1: TMenuItem; + InsertNewTile1: TMenuItem; + PreviousTile1: TMenuItem; + NextTile1: TMenuItem; + N16: TMenuItem; + FirstTile1: TMenuItem; + LastTile1: TMenuItem; + pBack: TPanel; + pMid: TPanel; + pFront: TPanel; + bmpBack: TImage; + bmpMid: TImage; + bmpFront: TImage; + pPreview: TPanel; + bmpPreview: TImage; + StretchPaste1: TMenuItem; + ToggleMultiple1: TMenuItem; + bUps: TSpeedButton; + mUps: TSpeedButton; + fUps: TSpeedButton; + bMir: TSpeedButton; + mMir: TSpeedButton; + fMir: TSpeedButton; + bRot: TSpeedButton; + mRot: TSpeedButton; + fRot: TSpeedButton; + FlipCurrentTile1: TMenuItem; + Horizontal2: TMenuItem; + Vertical2: TMenuItem; + SelectCurrentTile1: TMenuItem; + SelectBackMidFront1: TMenuItem; + Next1: TMenuItem; + Previous1: TMenuItem; + ToggleTileMapEditor1: TMenuItem; + LeftPanel: TPanel; + ToolPanel: TPanel; + PencilButton: TSpeedButton; + LineButton: TSpeedButton; + RectButton: TSpeedButton; + RoundRectButton: TSpeedButton; + EllipseButton: TSpeedButton; + BrushButton: TSpeedButton; + FillButton: TSpeedButton; + FilledRectButton: TSpeedButton; + FilledRoundRectButton: TSpeedButton; + FilledEllipseButton: TSpeedButton; + LightButton: TSpeedButton; + DarkButton: TSpeedButton; + PlusButton: TSpeedButton; + RandomButton: TSpeedButton; + LineToolPanel: TPanel; + LineTool: TShape; + ExtraPanel: TPanel; + BoundPanel: TPanel; + BoundBox: TPaintBox; + MapCodeButton: TSpeedButton; + MapTab: TTabControl; + MapScrollBox: TScrollBox; + MapDisplay: TPaintBox; // 2.42 + ClipTab: TTabControl; + ClipScrollBox: TScrollBox; + UsedColors: TPanel; + ShowUsedColors1: TMenuItem; + UsedColorsImage: TImage; + N18: TMenuItem; + MapProperties1: TMenuItem; + InvPanel: TPanel; + ShowGrid1: TMenuItem; + MapToolPanel: TPanel; + MapPointButton: TSpeedButton; + MapRectButton: TSpeedButton; + ShowMapCodes1: TMenuItem; + bmp1: TImage; + bmp2: TImage; + ShowBounds1: TMenuItem; + SelBmp: TImage; + ZOrderButton: TSpeedButton; + BlockButton: TSpeedButton; + N20: TMenuItem; + ClearArea1: TMenuItem; + ClipBitmap: TImage; + RandomFill1: TMenuItem; + N21: TMenuItem; + RemoveTileSet1: TMenuItem; + RemoveMap1: TMenuItem; + OpenDialog: TOpenDialog; + SaveDialog: TSaveDialog; + AnimationTimer: TTimer; + Animation1: TMenuItem; + FirstFrame1: TMenuItem; + LastFrame1: TMenuItem; + N22: TMenuItem; + NextFrame1: TMenuItem; + Animate1: TMenuItem; + PreviousFrame1: TMenuItem; + N23: TMenuItem; + Faster1: TMenuItem; + Slower1: TMenuItem; + AnimationSpeed1: TMenuItem; + Default1: TMenuItem; + TileModeButton: TToolButton; + MapModeButton: TToolButton; + ToolButton8: TToolButton; + ToolButton5: TToolButton; + AnimateButton: TToolButton; + ToolButton6: TToolButton; + ToolButton9: TToolButton; + ToolButton10: TToolButton; + SeqTab: TTabControl; + N24: TMenuItem; + ConverttoTileSequence1: TMenuItem; + InsertTileSequence1: TMenuItem; + RemoveTileSequence1: TMenuItem; + SeqBitmap: TImage; + SeqTimer: TTimer; + Code1: TMenuItem; + Generate1: TMenuItem; + CodeGenerationSettings1: TMenuItem; + PreviousPattern1: TMenuItem; + NextPattern1: TMenuItem; + ColorPatterns1: TMenuItem; + AddColorPattern1: TMenuItem; + RemoveColorPattern1: TMenuItem; + N17: TMenuItem; + SelectOutputDirectory1: TMenuItem; + ReplaceColors1: TMenuItem; + ReplaceColorsButton: TToolButton; + MapScrollFunction1: TMenuItem; + N25: TMenuItem; + SaveCurrentTile1: TMenuItem; + ImportEdlev: TToolButton; + ToolButton12: TToolButton; + Sequence1: TMenuItem; + N19: TMenuItem; + InsertHorizontal1: TMenuItem; + DeleteHorizontal1: TMenuItem; + InsertVertical1: TMenuItem; + DeleteVertical1: TMenuItem; + Tutorial1: TMenuItem; + N26: TMenuItem; + N27: TMenuItem; + OutputtoProjectDirectory1: TMenuItem; + N28: TMenuItem; + RecentProjects1: TMenuItem; + SmoothPalette1: TMenuItem; + N29: TMenuItem; + PaletteManager1: TMenuItem; + N30: TMenuItem; + ImportPovRayanimation1: TMenuItem; + MovePixels1: TMenuItem; + Right3: TMenuItem; + Left3: TMenuItem; + Down2: TMenuItem; + Up2: TMenuItem; + NoDelay1: TMenuItem; + ShowCurrentPalette1: TMenuItem; + N31: TMenuItem; + ImportMap1: TMenuItem; + ImportMapDialog: TOpenDialog; + ExportMapDialog: TSaveDialog; + ExportMap1: TMenuItem; + RefreshImportedTiles1: TMenuItem; + SelectionButton: TSpeedButton; + TileSelection: TShape; + GradientFill1: TMenuItem; + Horizontal3: TMenuItem; + Vertical3: TMenuItem; + Diagonal1: TMenuItem; + N32: TMenuItem; + ProjectInformation1: TMenuItem; + Fill1: TMenuItem; + Lighten1: TMenuItem; + Darken1: TMenuItem; + N33: TMenuItem; + N7: TMenuItem; + RealTimeLightening1: TMenuItem; + RTTimer: TTimer; + N34: TMenuItem; + Darker1: TMenuItem; + Lighter1: TMenuItem; + ChangeOffset1: TMenuItem; + Up3: TMenuItem; + Down3: TMenuItem; + Left4: TMenuItem; + Right4: TMenuItem; + ResetOffset1: TMenuItem; + HideTileSetPanel1: TMenuItem; + N35: TMenuItem; + UseOldNoiseFunctions1: TMenuItem; + ExportMapasImage1: TMenuItem; + RotateRight1: TMenuItem; + RotateLeft1: TMenuItem; + AntiAliasing1: TMenuItem; + aaOff: TMenuItem; + aa2: TMenuItem; + aa3: TMenuItem; + aa4: TMenuItem; + ReplaceColors2: TMenuItem; + Grid: TImage; + ShowTileGrid1: TMenuItem; + ReplaceSelectedTile1: TMenuItem; + N36: TMenuItem; + MoveMapLeft1: TMenuItem; + MoveMapRight1: TMenuItem; + NextMap1: TMenuItem; + PreviousMap1: TMenuItem; + N37: TMenuItem; + MapExportScaleDownFactor1: TMenuItem; + N210: TMenuItem; + N41: TMenuItem; + N82: TMenuItem; + N110: TMenuItem; + SplitColorPattern1: TMenuItem; + ShowMapLayer1: TMenuItem; + ShowBackLayer: TMenuItem; + ShowMidLayer: TMenuItem; + ShowFrontLayer: TMenuItem; + SetGridGuidelines1: TMenuItem; + ScaledPaste1: TMenuItem; + HalfSize1: TMenuItem; + N256ColorPalette1: TMenuItem; + N38: TMenuItem; + ReplaceCurrentTileSequence1: TMenuItem; + HistoryPanel: TPanel; + HistoryControlPanel: TPanel; + HistoryListBox: TListBox; + bHistoryRec: TSpeedButton; + bHistoryShow: TSpeedButton; + bHistoryClear: TSpeedButton; + ProjectLists1: TMenuItem; + UtilsTab: TPageControl; + RGBTab: TTabSheet; + PosTab: TTabSheet; + RGBPanel: TPanel; + RGBControlPanel: TPanel; + bRGBConvertAll: TSpeedButton; + bRGBEdit: TSpeedButton; + bRGBRun: TSpeedButton; + RGBConvListBox: TListBox; + Clip1: TMenuItem; + SelectNextClip1: TMenuItem; + SelectPreviousClip1: TMenuItem; + ReplaceColorUnderCursor1: TMenuItem; + OpacityTrackBar: TTrackBar; + N39: TMenuItem; + UseAsAlphaChannel1: TMenuItem; + AlphaPanel: TPanel; + AlphaPaintBox: TPaintBox; + ColorPatternsPanel: TPanel; + ColorPatternsImage: TImage; + N40: TMenuItem; + ShowUsedColorPatterns1: TMenuItem; + DoubleSize1: TMenuItem; + HideOnionSkin1: TMenuItem; + procedure Exit1Click(Sender: TObject); + procedure PalettePaint(Sender: TObject); + procedure FormResize(Sender: TObject); + procedure PaletteMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure PaletteMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure PaletteMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure FormCreate(Sender: TObject); + procedure BackGroundMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure RearrangePalette1Click(Sender: TObject); + procedure FromToPaint(Sender: TObject); + procedure FromToMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure FromToMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure FromToMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure ColorMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure ZoomIn1Click(Sender: TObject); + procedure ZoomOut1Click(Sender: TObject); + procedure TileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure TileMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure TileMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure SetDrawingTool(Sender: TObject); + procedure Up1Click(Sender: TObject); + procedure Down1Click(Sender: TObject); + procedure Left1Click(Sender: TObject); + procedure Right1Click(Sender: TObject); + procedure Horizontal1Click(Sender: TObject); + procedure Vertical1Click(Sender: TObject); + procedure Clear1Click(Sender: TObject); + procedure LineToolMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure Pattern1Click(Sender: TObject); + procedure ImportTiles1Click(Sender: TObject); + procedure NewTile1Click(Sender: TObject); + procedure TileBitmapMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure MatchColors1Click(Sender: TObject); + procedure Undo1Click(Sender: TObject); + procedure Redo1Click(Sender: TObject); + procedure Copy1Click(Sender: TObject); + procedure Paste1Click(Sender: TObject); + procedure Delete1Click(Sender: TObject); + procedure Cut1Click(Sender: TObject); + procedure MoveTileLeftClick(Sender: TObject); + procedure MoveTileRightClick(Sender: TObject); + procedure RemoveDuplicateTiles1Click(Sender: TObject); + procedure ColorMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure BackGroundMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure About1Click(Sender: TObject); + procedure Homepage1Click(Sender: TObject); + procedure ExportTiles1Click(Sender: TObject); + procedure BoundBoxPaint(Sender: TObject); + procedure Top1Click(Sender: TObject); + procedure Bottom1Click(Sender: TObject); + procedure Left2Click(Sender: TObject); + procedure Right2Click(Sender: TObject); + procedure DiagonalUp1Click(Sender: TObject); + procedure DiagonalDown1Click(Sender: TObject); + procedure ClearAll1Click(Sender: TObject); + procedure BoundBoxMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure NewTileCollection1Click(Sender: TObject); + procedure CreateNewTileCollection (Name: string; BW, BH: Integer; AddNew: Boolean); + procedure Properties1Click(Sender: TObject); + procedure TabChange(Sender: TObject); + procedure Toolbar1Click(Sender: TObject); + procedure ActualSize1Click(Sender: TObject); + procedure FitinWindow1Click(Sender: TObject); + procedure SetPaletteDepth(Sender: TObject); + procedure DuplicateTile1Click(Sender: TObject); + procedure SetBrightness(Sender: TObject); + procedure PaletteDblClick(Sender: TObject); + procedure SetEditorMode(NewMode: TEditorMode); + procedure BackgroundColor1Click(Sender: TObject); + procedure CopyTiles1Click(Sender: TObject); + procedure InsertNewTile1Click(Sender: TObject); + procedure PreviousTile1Click(Sender: TObject); + procedure NextTile1Click(Sender: TObject); + procedure FirstTile1Click(Sender: TObject); + procedure LastTile1Click(Sender: TObject); + procedure StretchPaste1Click(Sender: TObject); + procedure ToggleMultiple1Click(Sender: TObject); + procedure SelectBackMidFront(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure MirTileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure fUpsClick(Sender: TObject); + procedure Horizontal2Click(Sender: TObject); + procedure Vertical2Click(Sender: TObject); + procedure SelectCurrentTile1Click(Sender: TObject); + procedure Next1Click(Sender: TObject); + procedure Previous1Click(Sender: TObject); + procedure ToggleTileMapEditor1Click(Sender: TObject); + procedure DrawBounds (c: TCanvas; X, Y, Wid, Ht, lw, Bounds, Color: Integer); + procedure MapCodeButtonClick(Sender: TObject); + procedure Map1Click(Sender: TObject); + procedure ShowUsedColors1Click(Sender: TObject); + procedure UsedColorsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + procedure UsedColorsImageMouseMove(Sender: TObject; Shift: TShiftState; + X, Y: Integer); + procedure UsedColorsImageMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure MapProperties1Click(Sender: TObject); + procedure MapTabChange(Sender: TObject); + procedure ShowGrid1Click(Sender: TObject); + procedure bmpMapMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure bmpMapMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + procedure bmpMapMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure SetMapDrawingTool(Sender: TObject); + procedure bmpPreviewMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure ShowMapCodes1Click(Sender: TObject); + procedure ShowBounds1Click(Sender: TObject); + procedure ClearArea1Click(Sender: TObject); + procedure ClipTabChange(Sender: TObject); + procedure RandomFill1Click(Sender: TObject); + procedure RemoveMap1Click(Sender: TObject); + procedure RemoveTileSet1Click(Sender: TObject); + procedure Save1Click(Sender: TObject); + procedure SaveAs1Click(Sender: TObject); + procedure Open1Click(Sender: TObject); + procedure NewGame1Click(Sender: TObject); + procedure Animate1Click(Sender: TObject); + procedure FirstFrame1Click(Sender: TObject); + procedure LastFrame1Click(Sender: TObject); + procedure NextFrame1Click(Sender: TObject); + procedure PreviousFrame1Click(Sender: TObject); + procedure AnimationTimerTimer(Sender: TObject); + procedure Default1Click(Sender: TObject); + procedure Faster1Click(Sender: TObject); + procedure Slower1Click(Sender: TObject); + procedure TileModeButtonClick(Sender: TObject); + procedure MapModeButtonClick(Sender: TObject); + procedure ConverttoTileSequence1Click(Sender: TObject); + procedure SeqTabChange(Sender: TObject); + procedure SeqTimerTimer(Sender: TObject); + procedure RemoveTileSequence1Click(Sender: TObject); + procedure InsertTileSequence1Click(Sender: TObject); + procedure Generate1Click(Sender: TObject); + procedure CodeGenerationSettings1Click(Sender: TObject); + procedure PreviousPattern1Click(Sender: TObject); + procedure NextPattern1Click(Sender: TObject); + procedure AddColorPattern1Click(Sender: TObject); + procedure RemoveColorPattern1Click(Sender: TObject); + procedure SelectOutputDirectory1Click(Sender: TObject); + procedure ReplaceColors1Click(Sender: TObject); + procedure MapScrollFunction1Click(Sender: TObject); + procedure SaveCurrentTile1Click(Sender: TObject); + procedure ImportEdlevClick(Sender: TObject); + procedure InsertHorizontal1Click(Sender: TObject); + procedure DeleteHorizontal1Click(Sender: TObject); + procedure InsertVertical1Click(Sender: TObject); + procedure DeleteVertical1Click(Sender: TObject); + procedure FormShow(Sender: TObject); + procedure Tutorial1Click(Sender: TObject); + procedure OutputtoProjectDirectory1Click(Sender: TObject); + procedure SmoothPalette1Click(Sender: TObject); + procedure PaletteManager1Click(Sender: TObject); + procedure ImportPovRayanimation1Click(Sender: TObject); + procedure Up2Click(Sender: TObject); + procedure Down2Click(Sender: TObject); + procedure Left3Click(Sender: TObject); + procedure Right3Click(Sender: TObject); + procedure NoDelay1Click(Sender: TObject); + procedure ShowCurrentPalette1Click(Sender: TObject); + procedure ImportMap1Click(Sender: TObject); + procedure ExportMap1Click(Sender: TObject); + procedure RefreshImportedTiles1Click(Sender: TObject); + procedure TileSelectionMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure TileSelectionMouseMove(Sender: TObject; Shift: TShiftState; + X, Y: Integer); + procedure TileSelectionMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure Horizontal3Click(Sender: TObject); + procedure Vertical3Click(Sender: TObject); + procedure Diagonal1Click(Sender: TObject); + procedure ProjectInformation1Click(Sender: TObject); + procedure Fill1Click(Sender: TObject); + procedure Lighten1Click(Sender: TObject); + procedure FormClose(Sender: TObject; var Action: TCloseAction); + procedure RealTimeLightening1Click(Sender: TObject); + procedure RTTimerTimer(Sender: TObject); + procedure Darker1Click(Sender: TObject); + procedure Lighter1Click(Sender: TObject); + procedure Up3Click(Sender: TObject); + procedure Down3Click(Sender: TObject); + procedure Left4Click(Sender: TObject); + procedure Right4Click(Sender: TObject); + procedure ResetOffset1Click(Sender: TObject); + procedure MapDisplayPaint(Sender: TObject); + procedure HideTileSetPanel1Click(Sender: TObject); + procedure UseOldNoiseFunctions1Click(Sender: TObject); + procedure FormKeyPress(Sender: TObject; var Key: Char); + procedure ExportMapasImage1Click(Sender: TObject); + procedure RotateRight1Click(Sender: TObject); + procedure RotateLeft1Click(Sender: TObject); + procedure aaClick(Sender: TObject); + procedure ReplaceColors2Click(Sender: TObject); + procedure ShowTileGrid1Click(Sender: TObject); + procedure ReplaceSelectedTile1Click(Sender: TObject); + procedure MoveMapLeft1Click(Sender: TObject); + procedure MoveMapRight1Click(Sender: TObject); + procedure NextMap1Click(Sender: TObject); + procedure PreviousMap1Click(Sender: TObject); + procedure N110Click(Sender: TObject); + procedure SplitColorPattern1Click(Sender: TObject); + procedure ShowBackLayerClick(Sender: TObject); + procedure ShowMidLayerClick(Sender: TObject); + procedure ShowFrontLayerClick(Sender: TObject); + procedure SetGridGuidelines1Click(Sender: TObject); + procedure HalfSize1Click(Sender: TObject); + procedure N256ColorPalette1Click(Sender: TObject); + procedure ReplaceCurrentTileSequence1Click(Sender: TObject); + procedure bHistoryClearClick(Sender: TObject); + procedure bHistoryShowClick(Sender: TObject); + procedure HistoryListBoxClick(Sender: TObject); + procedure ProjectLists1Click(Sender: TObject); + procedure bRGBEditClick(Sender: TObject); + procedure bRGBRunClick(Sender: TObject); + procedure SelectNextClip1Click(Sender: TObject); + procedure SelectPreviousClip1Click(Sender: TObject); + procedure ReplaceColorUnderCursor1Click(Sender: TObject); + procedure Edit1Click(Sender: TObject); + procedure UseAsAlphaChannel1Click(Sender: TObject); + procedure AlphaPaintBoxPaint(Sender: TObject); + procedure ShowUsedColorPatterns1Click(Sender: TObject); + procedure ColorPatternsImageMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + procedure ColorPatternsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + procedure ColorPatternsImageMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + procedure DoubleSize1Click(Sender: TObject); + procedure Edit1DrawItem(Sender: TObject; ACanvas: TCanvas; + ARect: TRect; Selected: Boolean); + procedure HideOnionSkin1Click(Sender: TObject); + private + { Private declarations } + public + { Public declarations } + Modified: Boolean; + Mode: TEditorMode; + W, H: Integer; + Scale: Integer; + Bounds: Integer; + bmpMap, + Bmp, + TempBmp, + VisualBmp, + ClipBmp: TBitmap; + bmpMapImage: TBitmap; // 2.5 - export map + OnionSkinBmp: TBitmap; // 2.5 - onion skin + AlphaBmp: TBitmap; // 2.5 - use tile as alpha channel + LastTileEdited: Integer; + OnionSkinTile: Integer; + TileTab: array of TileTabRec; + // tbr: TileBitmapRec; + // IgnorePaletteMouseDown: Boolean; + ColorSelect, + RightMouseButton, + FromToSelect, + FromToBackgroundSelect: Boolean; + PaletteOrder: Integer; { 0..MAX_PALETTE_ORDER - 1 } + LastFromToFirst, + LastFromToLast, + FromToFirst, + FromToLast: Integer; + FromToList: TFromToList; + ExFromToList: TExFromToList; + FromToCount: Integer; + LineSize: array[TDrawingTool] of Integer; + Erasing, + ShiftErasing: Boolean; // 2.0 + Drawing: Boolean; + ReadingColor: Boolean; + ShowOrigin: Boolean; + OrigColor: Integer; + Origin, CurPos: TPoint; + LastX, LastY: Integer; + LastShift: TShiftState; + LastButton: TMouseButton; + Busy: Boolean; + DrawingTool: TDrawingTool; + DrawColor, + FillColor: Integer; + DrawingShape: Boolean; + LineList: string; + Undo: array[0..MAX_UNDO - 1] of UndoRec; + UndoCount, + UndoPos: Integer; + Action: string; + SpecialColor: Integer; + UsedColorSelect: Boolean; + UsedPatternSelect: Boolean; + MaxRGB, + MaxR, + MaxG, + MaxB: Integer; + PaletteValues: array of Integer; + PalW, PalH, PalNH, PalNV: Integer; + CursorSize: Integer; + RightPanelWidth: Integer; + BMFCenterAdd: Integer; + lmp, + Clip, + Seq: LayerMapPtr; + CurMapW, CurMapH: Integer; + ClipW, ClipH: Integer; + SeqW, SeqH, + SeqFrame: Integer; + // bmp1, bmp2: TImage; + Zoom: Integer; + Area, LastArea: TRect; + DrawingInMap, + ReadingFromMap: Boolean; + MapDrawingTool: TMapDrawingTool; + MapOrigin: TPoint; + MapPos: TPoint; + Selection: Boolean; + ShiftState: TShiftState; + SkipDraw: Boolean; + FromToSave: array of FTSaveRec; + FromToSavePos: Integer; + OtherFromTo: FTSaveRec; // 2.54 + StartTime: TDateTime; + Sessions: Integer; + History: string; + CDROM: Boolean; + ReadParamFile: Boolean;//CMDLINE_OP + resultCMD: Integer;//CMDLINE_OP + ReadParamCMD: string; + RecentFiles: TStringList; + WinLeft, WinTop, WinWidth, WinHeight: Integer; // 2.55 + TileSelX1, TileSelY1, // 2.0 + TileSelX2, TileSelY2: Integer; + TileAreaX, TileAreaY, TileAreaW, TileAreaH: Integer; + TileSelOrgX, TileSelOrgY: Integer; + MovingTileSel, MovingTileSelPixels: Boolean; + GradientH, GradientV, GradientD: Boolean; // 2.0 + VisibleMapRegion: TRect; // 2.42 + + XShade: Integer; // 2.44 + YShade: Integer; + + aaN: Integer; // 2.5 + + MapGridX, MapGridY: Integer; // 2.54 + Quitting: Boolean; // 2.54 + + Pal256: Boolean; // 3.0 + Index256: Integer; + Row256: Integer; + LastIndex256: Integer; + Enable256, + LastEnable256: array[0..255] of Boolean; + + RGBConvScripts: array of TStringList; + + ColorUnderMousePointer: Integer; + + + procedure UpdateRecentFilesMenu; + function ColorMatch (C: Integer): Integer; + procedure InitUndo; + procedure ClearUndo; + procedure SaveUndo (Action: string); + procedure UpdateTileBitmap; + procedure UpdateBmp (UpdateAll: Boolean); + procedure SetTileSize (Width, Height: Integer); + procedure SetFromTo (N: Integer); + procedure DrawUsedFromToList; + procedure SetColor (NewColor: Integer; SetFT: Boolean; AddFT: Boolean); + procedure SetBackgroundColor (NewColor: Integer; Select: Boolean); + procedure DrawShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + procedure DrawFTShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + procedure DrawFTCircle (C: TCanvas; xp, yp: Integer; Shift: Boolean); + procedure DrawCursor; + procedure ShowStatusInfo; + procedure StartEdit (UpdateAll: Boolean); + procedure SwapWithUndo; + procedure SaveTempBmp; + procedure ShowRGB (color: Integer); + procedure HFlipBounds (var Bounds: Integer); + procedure VFlipBounds (var Bounds: Integer); + procedure RotateBounds (var Bounds: Integer; deg: Integer); + function NewTCName: string; + function NewMapName: string; + function TCNameOK (s: string; MayExist: Boolean): Boolean; + procedure IdError (id: string); + function HasCurrentBounds (Tile: SmallInt): Boolean; + procedure GetMCRTile (var MCR: MapCellRec; var Tile: Integer; + var Mir: Boolean; var Ups: Boolean); + procedure SetMCRTile (var MCR: MapCellRec; Tile: Integer; + Mir, Ups: Boolean); + procedure AddMCR (var MCR: MapCellRec; n: Integer); + procedure MirSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + procedure UpsSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + procedure DrawTile (TabIndex, N: Integer; var bmp: TImage; + var Mir: Boolean; var Ups: Boolean; var Rot: Boolean; + var FullBmp: TImage); + procedure DrawCurrentTile; + procedure ShowSelectedTile; + procedure SelectCurrentTile (n: Integer); + procedure HideUsedColors; + procedure DrawMap (Area: TRect; ExportingImage: Boolean; Clp, Sq: Boolean); + procedure ZoomMap; + function CombineMCR (OldMCR, NewMCR: MapCellRec): MapCellRec; + procedure CloseAll; + function SaveChanges: Boolean; + procedure ToggleAnimation; + function FindCurrentColorPattern (FindColor: Integer; All: Boolean): Integer; + procedure FindPatternForColor; + procedure SelectSavedFromToList; +{$IFDEF IMPORTEDLEV} + procedure ImportLevelTiles (dir, name: string; ww, hh: Integer; extc: Char = #0); + procedure ImportAnySize (dir: string; extc: Char); + procedure ImportLevelMap (dir, filename, name: string); +{$ENDIF} + procedure RecentFileClick (Sender: TObject); + procedure AddFileToRecentProjects (Filename: string); + procedure ReadConfigFile; + procedure WriteConfigFile; + procedure ShowTileSelection (Clip: Boolean); + procedure GetTileArea; + procedure SwapInt (var x, y: Integer); + function ColorPerc (RGB1, RGB2, Perc2, MaxPerc: Integer): Integer; + function ColorPercFT (i1, i2, Perc2, MaxPerc: Integer): Integer; + procedure UpdateMap; + procedure UpdateMapRegion(Region: TRect); + procedure UpdateTileGrid; + function CountEnabledColors: Integer; + procedure SaveHistoryCoords (x1, y1, x2, y2: Integer); + procedure LoadRGBConvNames; + function ConvertPixel (color: Integer): Integer; + end; + +var + MainForm: TMainForm; + +implementation + +uses Import, Clipbrd, About, Create, TileCopy, MCEdit, Hex, CGSettings, + SelectDir, Export, Scroll, Calc, PalMan, ImpPovAni, ReplaceColors, + InfoForm, Settings, ListsForm, RGBConvForm; + +{$R *.DFM} + + + +procedure ShowMessage (const sMsg: string); +begin + MessageDlg (sMsg, mtInformation, [mbOK], 0); +end; + + +var + DtTm: TDateTime; + aiDtTm: array[0..1] of Integer absolute DtTm; + +function UpCaseStr (s: string): string; + var + i: Integer; +begin + for i := 1 to Length (s) do + s[i] := UpCase (s[i]); + UpCaseStr := s; +end; + +function FileExists (Filename: string): Boolean; + var + SR: TSearchRec; +begin + Result := FindFirst (Filename, faArchive, SR) = 0; + FindClose (SR); +end; + +function DirExists (Filename: string): Boolean; + var + SR: TSearchRec; +begin + Result := FindFirst (Filename, faDirectory, SR) = 0; + FindClose (SR); +end; + +procedure Msg (s: string); +begin + MessageDlg (s, mtInformation, [mbOk], 0); +end; + + +function FilePath (Name: string): string; +begin + if Pos ('\', Name) = 0 then + FilePath := '' + else + begin + while (Length (Name) > 0) and (Name[Length (Name)] <> '\') do + Delete (Name, Length (Name), 1); + FilePath := Name; + end; +end; + +function WithoutPath (Name: string): string; + var + i: Integer; +begin + i := Length (Name); + while (i > 0) and (Name[i] <> '\') do + Dec (i); + Delete (Name, 1, i); + WithoutPath := Name; +end; + +function WithoutExt (Name: string; Ext: string): string; + var + { i: Integer; } + sPath, sFile: string; +begin +{ + i := Pos (Ext, Name); + if i <> Length (Name) - Length (Ext) + 1 then + WithoutExt := Name + else + WithoutExt := Copy (Name, 1, Length (Name) - Length (Ext)); +} + // 2.34 + sPath := FilePath (Name); + sFile := WithoutPath (Name); + while Pos ('.', sFile) > 0 do + Delete (sFile, Length (sFile), 1); + WithoutExt := sPath + sFile; +end; + +function CreatePath (Name: string): string; + var + i: Integer; + p, s: string; +begin + s := Name; + while Pos ('\', s) > 0 do + begin + i := Pos ('\', s); + p := Copy (Name, 1, i - 1); + if not ((Length (p) = 2) and (p[2] = ':')) then + if not DirExists (p) then + mkdir (p); + s[i] := #0; + end; +end; + +function ProjectName: string; + var + Name: string; +begin + Name := Filename; + if Name = '' then + Name := DEFAULT_NAME + DEFAULT_EXT; + ProjectName := WithoutPath (WithoutExt (Name, DEFAULT_EXT)); +end; + +function ValidNumber (var s: string): Boolean; + var + N: Integer; + Code: Integer; +begin + if (Length (s) > 1) then + if Copy (UpCaseStr (s), 1, 2) = '0X' then + begin + Delete (s, 1, 2); + Insert ('$', s, 1); + Val (s, N, Code); + Str (N, s); + end; + Val (s, N, Code); + ValidNumber := Code = (N - N); +end; + +procedure ResizeBitmap (var img: TImage); +begin + img.Picture.Bitmap.PixelFormat := pf24bit; + img.Picture.Bitmap.Width := img.Width; + img.Picture.Bitmap.Height := img.Height; +end; + +procedure FillBitmap (var img: TImage; rgb: Integer); + var + i: Integer; +begin + img.Picture.Bitmap.PixelFormat := pf24bit; + with img.Picture.Bitmap.Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := rgb; + i := pen.Width; + FillRect (Rect (-i, -i, + img.Picture.Bitmap.Width + i, + img.Picture.Bitmap.Height + i)); + end; +end; + +procedure TMainForm.InitUndo; + var + i: Integer; +begin + for i := 0 to MAX_UNDO - 1 do + begin + Undo[i].Bmp := TBitmap.Create; + Undo[i].Bmp.PixelFormat := pf24bit; + end; +end; + +procedure TMainForm.ClearUndo; +begin + UndoCount := 0; + UndoPos := -1; + Redo1.Enabled := FALSE; +{ + RedoButton.Down := FALSE; + RedoButton.Enabled := FALSE; +} + Undo1.Enabled := FALSE; +{ + UndoButton.Down := FALSE; + UndoButton.Enabled := FALSE; +} +end; + +procedure TMainForm.SaveUndo (Action: string); + var + i: Integer; + ur: UndoRec; +begin + if UndoPos + 1 <> UndoCount then + begin + UndoCount := UndoPos + 1; + Redo1.Caption := '&Redo'; + Redo1.Enabled := FALSE; + { + RedoButton.Down := FALSE; + RedoButton.Enabled := FALSE; + } + end; + if UndoCount >= MAX_UNDO - 1 then + begin + ur := Undo[0]; + for i := 0 to UndoCount - 1 do + Undo[i] := Undo[i + 1]; + Undo[UndoCount] := ur; // don't lose initialized TBitmaps! + end + else + begin + Inc (UndoCount); + Inc (UndoPos); + end; + Undo[UndoPos].Bmp.Width := W; + Undo[UndoPos].Bmp.Height := H; + Undo[UndoPos].Bmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + Undo[UndoPos].ActionName := Action; + Undo[UndoPos].HistoryCoords := ''; + + Undo1.Caption := '&Undo ' + Action; + Undo1.Enabled := TRUE; +{ + UndoButton.Enabled := TRUE; +} +end; + +procedure TMainForm.Exit1Click(Sender: TObject); +begin +// if Modified then +// if not SaveChanges then +// Exit; + Close; +end; + + +function LimitRGB (X: Integer): Integer; +begin + if X < 0 then + LimitRGB := 0 + else + if X > 255 then + LimitRGB := 255 + else + LimitRGB := X; +end; + +function MakePalRGB (r, g, b, l: Integer): Integer; + var + Light: Integer; +begin + Light := l; + MakePalRGB := RGB (LimitRGB (r + Light), + LimitRGB (g + Light), + LimitRGB (b + Light)); +end; + + + +procedure TMainForm.PalettePaint(Sender: TObject); + var + Max: Integer; + iW, iH, x1, y1, x2, y2, k: Integer; + R, G, B, RR, GG, BB: Integer; + Wd, Ht: Integer; + i, j, l, m, n, p: Integer; + OldShowCurPal: Boolean; + Bmp: TBitmap; + + function GetColorCircle (i, j: Integer): Integer; + var + k, l, m, n: Integer; + begin + k := (j * 6) mod Ht; + l := (j * 6) div Ht; + m := 256 * k div Ht; + n := 256 - m; + case l of + 0: begin + RR := 255; + GG := 0; + BB := n; + // BB := Round (256 * Cos (k / Ht)); + end; + 1: begin + RR := 255; + GG := m; + BB := 0; + end; + 2: begin + RR := n; + GG := 255; + BB := 0; + end; + 3: begin + RR := 0; + GG := 255; + BB := m; + + end; + 4: begin + RR := 0; + GG := n; + BB := 255; + end; + else + begin + RR := m; + GG := 0; + BB := 255; + end; + end; + + Result := MakePalRGB (i * RR div Wd, + i * GG div Wd, + i * BB div Wd, + i * 255 div Wd); + end; + +begin + Max := MaxR * MaxG * MaxB; + iW := 2 * MaxB; + iH := Max div iW; + + if Pal256 then + begin + iW := 8; + iH := 32; + end; + + j := (RightPanel.Height div 2) div iH * iH + 10; + if j <> PalettePanel.Height then + PalettePanel.Height := j; + + Wd := Palette.Width; + Ht := Palette.Height; + if Ht > 2 * Wd then + begin + iW := 1 * MaxB; + iH := Max div iW; + end; + if Wd > Ht then + begin + iW := 3 * MaxB; + iH := Max div iW; + end; + + if Pal256 then + begin + Max := 256; + iW := 8; + iH := 32; + end; + + SetLength (PaletteValues, Max); + PalNH := iW; + PalNV := iH; + PalW := Wd; + PalH := Ht; + + with Palette.Canvas do + begin + if Pal256 then + begin // 256-color palette + with TileTab[Tab.TabIndex].tbr do + begin + p := PaletteNumber; + OldShowCurPal := ShowCurrentPalette1.Checked; + ShowCurrentPalette1.Checked := FALSE; + + + for k := 0 to 255 do + begin + + Brush.Color := 0; + if (p >= 0) then + begin + if (k < aiPalSize[p]) then + Brush.Color := aaiPal[p, k]; + end + else + Brush.Color := GetColorCircle (Wd * (k mod 8) div 8, Ht * (k div 8) div 32); + + Brush.Style := bsSolid; + Pen.Style := psClear; + x1 := (k mod iW) * Wd div iW; + y1 := (k div iW) * Ht div iH; + x2 := ((k mod iW) + 1) * Wd div iW; + y2 := ((k div iW) + 1) * Ht div iH; + Rectangle (x1, y1, x2 + 1, y2 + 1); + PaletteValues[k] := Brush.Color; + + if not Enable256[k] then + begin + Brush.Style := bsBDiagonal; + Brush.Color := clBlack; + Rectangle (x1, y1, x2 + 1, y2 + 1); + Brush.Style := bsFDiagonal; + Brush.Color := clWhite; + Rectangle (x1, y1, x2 + 1, y2 + 1); + end; + end; + + + ShowCurrentPalette1.Checked := OldShowCurPal; + end; + end + else + begin + if not SmoothPalette1.Checked then // generated 6x6x6/7x7x7/8x8x8 palettes + begin + OldShowCurPal := ShowCurrentPalette1.Checked; + ShowCurrentPalette1.Checked := FALSE; + k := 0; + for R := 0 to MaxR - 1 do + for G := 0 to MaxG - 1 do + for B := 0 to MaxB - 1 do + begin + case PaletteOrder of + 1: begin RR := G; GG := B; BB := R; end; + 2: begin RR := B; GG := R; BB := G; end; + 3: begin RR := R; GG := B; BB := G; end; + 4: begin RR := G; GG := R; BB := B; end; + 5: begin RR := B; GG := G; BB := R; end; + else begin RR := R; GG := G; BB := B; end; + end; + Brush.Color := + ColorMatch (RGB (RR * 255 div (MaxR - 1), + GG * 255 div (MaxG - 1), + BB * 255 div (MaxB - 1))); + Brush.Style := bsSolid; + Pen.Style := psClear; + x1 := (k mod iW) * Wd div iW; + y1 := (k div iW) * Ht div iH; + x2 := ((k mod iW) + 1) * Wd div iW; + y2 := ((k div iW) + 1) * Ht div iH; + Rectangle (x1, y1, x2 + 1, y2 + 1); + + PaletteValues[k] := Brush.Color; + + Inc (k); + end; + ShowCurrentPalette1.Checked := OldShowCurPal; + end + else + begin // smooth palette + + //for j := 0 to Ht - 1 do + // for i := 0 to Wd - 1 do + // Pixels[i, j] := GetColorCircle (i, j); // very slow for some reason + + Bmp := TBitmap.Create(); + Bmp.Width := Wd; + Bmp.Height := Ht; + + for j := 0 to Ht - 1 do + for i := 0 to Wd - 1 do + Bmp.Canvas.Pixels[i, j] := GetColorCircle (i, j); + + Draw(0, 0, Bmp); + + Bmp.FreeImage(); + + end; + end; + + end; + + RearrangePalette1.Enabled := not SmoothPalette1.Checked; +end; + +procedure TMainForm.FormResize(Sender: TObject); + var + Wd, Ht: Integer; + X, Y: Integer; + i: Integer; +begin + if Quitting then Exit; + + Wd := (W + 2 * BORDER_W) * Scale; + Ht := (H + 2 * BORDER_H) * Scale; + X := ScrollBox.ClientWidth div 2 - Wd div 2; + Y := ScrollBox.ClientHeight div 2 - Ht div 2; + if X < 0 then + X := 0; + if Y < 0 then + Y := 0; + with Tile do + begin + Left := X; + Top := Y; + Width := Wd; + Height := Ht; + end; + + Palette.Repaint; + i := RightPanel.Height - PalettePanel.Height - ColorsPanel.Height - ProgressPanel.Height; + PatternPanel.Height := PatternPanel.Width; + if PatternPanel.Height > i then + PatternPanel.Height := i; + UpdateBmp (TRUE); + + if Mode = mTile then + begin + StatusBar.Panels[4].Text := Format ('%dx', [Scale]); + ZoomOut1.Enabled := (Scale > 1); + ZoomIn1.Enabled := (Scale < MAX_SCALE); + end; + if Mode = mMap then + begin + ZoomIn1.Enabled := (Zoom > 1); + ZoomOut1.Enabled := (Zoom < MAX_ZOOM); + end; + + DrawCursor; +end; + +procedure TMainForm.PaletteMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + i, j, k: Integer; +begin +{ + if IgnorePaletteMouseDown then + begin + IgnorePaletteMouseDown := FALSE; + Exit; + end; +} + LastIndex256 := -1; + + i := X * PalNH div PalW; + j := Y * PalNV div PalH; + + if (i >= 0) and (i < PalNH) and (j >= 0) and (j < PalNV) then + begin + Row256 := 32 * j div PalNV; + Index256 := Row256 * 8 + (8 * i div PalNH); + + if SmoothPalette1.Checked then + k := Palette.Canvas.Pixels[X - 1, Y - 1] + else + k := PaletteValues[j * PalNH + i]; + end; + + if Button = mbLeft then + begin + if k = Color.Brush.Color then + Inc (FromToCount); + ColorSelect := TRUE; + end; + if Button = mbRight then + RightMouseButton := TRUE; + PaletteMouseMove (Sender, Shift, X, Y); +end; + +procedure GetRGB (RGB: Integer; var R: Integer; var G: Integer; var B: Integer); +begin + R := RGB; + G := RGB div $100; + B := RGB div $10000; + R := R and $FF; + G := G and $FF; + B := B and $FF; +end; + +function ColorBetween (RGB1, RGB2: Integer): Integer; + var + R1, G1, B1: Integer; + R2, G2, B2: Integer; + C: Integer; +begin + GetRGB (RGB1, R1, G1, B1); + GetRGB (RGB2, R2, G2, B2); + C := RGB ((R1 + R2) div 2, (G1 + G2) div 2, (B1 + B2) div 2); + if C = TRANS_COLOR then + if (RGB1 <> TRANS_COLOR) and (RGB2 <> TRANS_COLOR) then + Inc (C); + ColorBetween := C; +end; + +function Grey (RGB: Integer): Integer; + var + R, G, B: Integer; +begin + GetRGB (RGB, R, G, B); + Grey := (R + G + B) div 3; +end; + +function Blend (RGB1, RGB2: Integer; w1, w2: Integer): Integer; + var + R1, G1, B1: Integer; + R2, G2, B2: Integer; + C: Integer; +begin + GetRGB (RGB1, R1, G1, B1); + GetRGB (RGB2, R2, G2, B2); + C := RGB ((w1 * R1 + w2 * R2) div (w1 + w2), + (w1 * G1 + w2 * G2) div (w1 + w2), + (w1 * B1 + w2 * B2) div (w1 + w2)); + if C = TRANS_COLOR then + if (RGB1 <> TRANS_COLOR) and (RGB2 <> TRANS_COLOR) then + Inc (C); + Blend := C; +end; + +procedure TMainForm.PaletteMouseMove(Sender: TObject; Shift: TShiftState; + X, Y: Integer); + var + i, j, k, Index: Integer; + ft: Integer; + R, G, B: Integer; +begin + i := X * PalNH div PalW; + j := Y * PalNV div PalH; + if (i >= 0) and (i < PalNH) and (j >= 0) and (j < PalNV) then + begin + Index := j * PalNH + i; + if SmoothPalette1.Checked then + k := Palette.Canvas.Pixels[X - 1, Y - 1] + else + k := PaletteValues[j * PalNH + i]; + + if Pal256 then + begin + k := PaletteValues[Index]; + + if ColorSelect then + if not Enable256[Index] then + if CountEnabledColors < 256 then + begin + LastEnable256 := Enable256; + for i := 0 to 255 do + Enable256[i] := True; + Palette.Repaint; + end; + end; + + // 2.0 select from current color to new + + if ssShift in Shift then + begin + ShowRGB (k); + + if ColorSelect then + begin + + if (FromToFirst = FromToLast) then + begin + for ft := 0 to MAX_FROM_TO - 1 do + FromToList[ft] := ColorPerc (Color.Brush.Color, + k, ft, MAX_FROM_TO); + FromToFirst := 0; + FromToLast := MAX_FROM_TO - 1; + end + else + begin + for ft := FromToFirst + 1 to FromToLast do + FromToList[ft] := ColorPerc (FromToList[FromToFirst], + k, Abs (ft - FromToFirst), + Abs (FromToLast - FromToFirst)); + for ft := FromToFirst - 1 downto FromToLast do + FromToList[ft] := ColorPerc (FromToList[FromToFirst], + k, Abs (ft - FromToFirst), + Abs (FromToLast - FromToFirst)); + end; + + end; + + // 2.43 (bug fix) + for ft := 0 to MAX_FROM_TO - 1 do + begin + GetRGB (FromToList[ft], R, G, B); + ExFromToList[ft, 0] := R; + ExFromToList[ft, 1] := G; + ExFromToList[ft, 2] := B; + end; + FromToPaint (Sender); + + end + else + begin + ShowRGB (k); + if ColorSelect then + SetColor (k, TRUE, ssCtrl in Shift); + end; + + + if RightMouseButton then + if Pal256 then + begin + j := Byte (not Enable256[Index]); + if Index <> LastIndex256 then + begin + case (2 * byte (ssCtrl in Shift) + byte (ssShift in Shift)) of + 1: begin { shift } + for i := 0 to 7 do + Enable256[(Index and (not 7)) + i] := Boolean (j); + LastIndex256 := Index; + Palette.Repaint; + end; + 2: begin { ctrl } + Enable256[Index] := Boolean (j); + LastIndex256 := Index; + Palette.Repaint; + end; + 3: begin { shift + ctrl } + for i := 0 to 255 do + Enable256[i] := False; + for i := 0 to 7 do + Enable256[(Index and (not 7)) + i] := True; + LastIndex256 := Index; + Palette.Repaint; + ShowRGB (k); + ColorSelect := TRUE; + SetColor (k, TRUE, FALSE); + ColorSelect := FALSE; + end; + + else + if CountEnabledColors = 256 then + SetBackgroundColor (k, FALSE) + else + begin + for i := 0 to 255 do + Enable256[i] := Boolean (j); + LastIndex256 := Index; + Palette.Repaint; + end; + + end; + end; + + + end + else + SetBackgroundColor (k, FALSE); + + end; +end; + +procedure TMainForm.PaletteMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + ColorSelect := FALSE; + if Button = mbRight then + RightMouseButton := FALSE; +end; + + +procedure TMainForm.UpdateRecentFilesMenu; + var + mi: TMenuItem; + i, j: Integer; +begin + for i := RecentProjects1.Count - 1 downto 0 do + RecentProjects1.Delete (i); + j := RecentFiles.Count; + if j > 9 then + j := 9; + for i := 0 to j - 1 do + begin + mi := TMenuItem.Create (MainMenu); + mi.Caption := '&' + IntToStr (i + 1) + ' ' + RecentFiles.Strings[i]; + mi.Tag := i; + mi.OnClick := RecentFileClick; + RecentProjects1.Add (mi); + end; + RecentProjects1.Enabled := RecentFiles.Count > 0; +end; + + +procedure TMainForm.FormCreate(Sender: TObject); + var + s: string; + i: Integer; + F: TextFile; + tdt: TDrawingTool; +begin + StartTime := Now; + Sessions := 0; +{$IFDEF IMPORTEDLEV} + ImportEdlev.Visible := TRUE; +{$ENDIF} + + // 2.43 + for tdt := Low (LineSize) to High (LineSize) do + LineSize[tdt] := 1; + + CursorSize := DEFAULT_CURSOR_SIZE; + RightPanelWidth := RightPanel.Width; + LastFromToFirst := 0; + LastFromToLast := MAX_FROM_TO - 1; + Zoom := ZOOM_FACTOR; + + VisibleMapRegion := Rect(0, 0, 0, 0); + + ApplPath := ParamStr (0); + i := Length (ApplPath); + while (i > 0) and (ApplPath[i] <> '\') do + begin + Delete (ApplPath, Length (ApplPath), 1); + Dec (i); + end; + + + RecentFiles := TStringList.Create; + ReadConfigFile; + + + CDROM := FALSE; + try + AssignFile (F, ApplPath + '$TS$Tmp$.$$$'); + ReWrite (F); + CloseFile (F); + Erase (F); + except + CDROM := TRUE; + end; + if CDROM then + begin + ShowMessage ('Tile Studio is running from a read-only drive. '#13 + + 'Some options might not be available.'); + end; + + PatternPanel.Height := PatternPanel.Width; + Pattern.Height := Pattern.Width; + + Homepage1.Caption := APPL_NAME + ' &Homepage'; + OpenDialog.DefaultExt := DEFAULT_EXT; + SaveDialog.DefaultExt := DEFAULT_EXT; + s := APPL_NAME + ' Project (*' + DEFAULT_EXT + + ')|*' + DEFAULT_EXT + '|All files (*.*)|*.*'; + OpenDialog.Filter := s; + SaveDialog.Filter := s; + + MapDisplay.Canvas.Brush.Style := bsClear; + MapDisplay.ControlStyle := MapDisplay.ControlStyle + [csOpaque]; + bmpMap := TBitmap.Create; + bmpMap.PixelFormat := pfMap; + ClipBitmap.Picture.Bitmap.PixelFormat := pfMap; + SeqBitmap.Picture.Bitmap.PixelFormat := pfMap; + +{ bmp1 := TImage.Create (InvPanel); } + bmp1.Transparent := TRUE; + bmp1.Picture.Bitmap.TransparentColor := TRANS_COLOR; +{ bmp2:= TImage.Create (InvPanel); } + bmp2.Transparent := FALSE; + SelBmp.Transparent := TRUE; + SelBmp.Picture.Bitmap.TransparentColor := TRANS_COLOR; +{ + if not Ok then + begin + MessageDlg ('This program cannot run with 16 or 256 color display,' + + 'Please change your desktop settings to High Color or True Color.', + mtError, [mbOk], 0); + Close; + end; +} + + + // SetEditorMode (mTile); // [ 732697 ] Access violation when starting TS 2.41 on XP + + SpecialColor := SPECIAL_COLOR; + + MaxRGB := 8; + MaxR := 8; + MaxG := 8; + MaxB := 8; + + InitUndo; + ClearUndo; + + VisualBmp := TBitmap.Create; + VisualBmp.PixelFormat := pf24bit; + VisualBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(VisualBmp.Canvas.Handle, HALFTONE); + + TempBmp := TBitmap.Create; + TempBmp.PixelFormat := pf24bit; + TempBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(TempBmp.Canvas.Handle, HALFTONE); + + Bmp := TBitmap.Create; + Bmp.PixelFormat := pf24bit; + Bmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(Bmp.Canvas.Handle, HALFTONE); + + ClipBmp := TBitmap.Create; + ClipBmp.PixelFormat := pf24bit; + ClipBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(ClipBmp.Canvas.Handle, HALFTONE); + + OnionSkinBmp := TBitmap.Create; + OnionSkinBmp.PixelFormat := pf24bit; + OnionSkinBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(OnionSkinBmp.Canvas.Handle, HALFTONE); + OnionSkinTile := -1; + LastTileEdited := -1; + + AlphaBmp := TBitmap.Create; + AlphaBmp.PixelFormat := pf24bit; + AlphaBmp.TransparentColor := TRANS_COLOR; + SetStretchBltMode(AlphaBmp.Canvas.Handle, HALFTONE); + + + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + + SetEditorMode (mTile); // 2.43 moved to here + + StartEdit (TRUE); + + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + + Scale := DEFAULT_SCALE; + ColorSelect := FALSE; + RightMouseButton := FALSE; + FromToCount := 0; + SetBackgroundColor (DEFAULT_BACKGR_COLOR, FALSE); + SetColor (ColorMatch (DEFAULT_COLOR), TRUE, FALSE); +// SetFromTo (FromToCount); + Erasing := FALSE; + ShiftErasing := FALSE; + + PaletteOrder := 1; + SelectBackMidFront (pMid, mbLeft, [], 1, 1); + + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; + + ReadParamFile := ParamCount > 0; + if ReadParamFile then + FileToOpen := ParamStr (1); + + TileSelX1 := 0; + TileSelY1 := 0; + TileSelX2 := -1; + TileSelY2 := -1; + MovingTileSel := FALSE; + MovingTileSelPixels := FALSE; + + Busy := FALSE; + + Modified := FALSE; + + // apply config data + UpdateRecentFilesMenu; + + MainForm.Position := poDesigned; + MainForm.Left := WinLeft; + MainForm.Top := WinTop; + MainForm.Width := WinWidth; + MainForm.Height := WinHeight; + + + XShade := 0; + YShade := 0; + + ShowTileGrid1.Checked := Grid.Visible; + + MapGridX := 0; + MapGridY := 0; + Quitting := False; + + Pal256 := FALSE; + + ClipTab.Align := alClient; + UtilsTab.Align := alClient; + + LoadRGBConvNames; + +end; { FormCreate } + +procedure TMainForm.BackGroundMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Button = mbRight then + SetBackgroundColor (DEFAULT_BACKGR_COLOR, TRUE) + else + SetBackgroundColor (Background.Brush.Color, TRUE); +end; + +procedure TMainForm.UpdateTileBitmap; +begin + with TileTab[Tab.TabIndex] do + begin + TileBitmap.Picture.Bitmap := tbr.TileBitmap; + TileBitmap.Width := tbr.TileCount * tbr.W; + TileBitmap.Height := tbr.H; + TileBitmap.Picture.Bitmap.Width := tbr.TileCount * tbr.W; + TileBitmap.Picture.Bitmap.Height := tbr.H; + + with TileBitmap.Picture.Bitmap.Canvas do + begin + Brush.Color := BackGround.Brush.Color; + FillRect (Rect (0, 0, TileBitmap.Width, TileBitmap.Height)); + Draw (0, 0, tbr.TileBitmap); + end; + + end; +end; + +procedure TMainForm.UpdateBmp (UpdateAll: Boolean); + var + x, y, i, j, k, ov: Integer; + TmpBmp: TBitmap; + + procedure ClearEdge; + var + ov: Integer; + begin + with VisualBmp.Canvas do + begin + Pen.Style := psClear; + Brush.Style := bsSolid; + Brush.Color := ColorBetween (Background.Brush.Color, clSilver); + FillRect (MakeRect (0, 0, W + 2 * BORDER_W, BORDER_H)); + FillRect (MakeRect (0, BORDER_H, BORDER_W, H)); + FillRect (MakeRect (W + BORDER_W, BORDER_H, BORDER_W, H)); + FillRect (MakeRect (0, H + BORDER_H, W + 2 * BORDER_W, BORDER_H)); + ov := TileTab[Tab.TabIndex].tbr.Overlap; + if ov > 0 then + begin + Brush.Color := ColorBetween (Brush.Color, clSilver); + FillRect (MakeRect (0, 0, W + 2 * BORDER_W, BORDER_H)); + FillRect (MakeRect (0, BORDER_H, BORDER_W, ov)); + FillRect (MakeRect (W + BORDER_W, BORDER_H, BORDER_W, ov)); + end; + end; + end; + + var + OfsX, OfsY: Integer; // 2.4 + tmpX1, tmpY1, tmpX2, tmpY2: Integer; // 3.0 + tmpS, sNum: string; + iCode: Integer; + oldRGB, newRGB: Integer; + opacity: Integer; + alpha: Integer; + w1, w2: Integer; + +begin { UpdateBMP } +// Caption := Format ('UndoPos: %d UndoCount: %d', [UndoPos, UndoCount]); + + ShowStatusInfo; + + if Quitting then Exit; + + if Mode = mTile then + begin + alpha := -1; + if UseAsAlphaChannel1.Checked then + if (AlphaBmp.Width = W) and (AlphaBmp.Height = H) then + begin + if LastTileEdited <> TileTab[Tab.TabIndex].tbr.Current then + LastTileEdited := TileTab[Tab.TabIndex].tbr.Current + else + alpha := 0; + end; + + // set opacity of last action + opacity := OpacityTrackBar.Position; + if UpdateAll then + if (opacity <> OpacityTrackBar.Max) or (alpha <> -1) then + if (UndoCount > 0) and (UndoPos >= 0) then + begin + for tmpY1 := 0 to H - 1 do + for tmpX1 := 0 to W - 1 do + begin + newRGB := Bmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H]; + oldRGB := Undo[UndoPos].Bmp.Canvas.Pixels[tmpX1, tmpY1]; + if (newRGB <> TRANS_COLOR) and (oldRGB <> TRANS_COLOR) then + begin + w1 := OpacityTrackBar.Max; + w2 := opacity; + + if alpha <> -1 then + begin + alpha := AlphaBmp.Canvas.Pixels[tmpX1, tmpY1]; + if (alpha = TRANS_COLOR) then + alpha := 0 + else + alpha := Grey (alpha); + w1 := 256 * OpacityTrackBar.Max; + w2 := 256 * alpha * opacity div 256; + end; + + //w1 := OpacityTrackBar.Max - opacity; + //w2 := opacity; + + + Bmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H] := Blend (oldRGB, newRGB, w1 - w2, w2); + + end; + end; + end; + + TmpBmp := TBitmap.Create; + SetStretchBltMode(TmpBmp.Canvas.Handle, HALFTONE); + with TmpBmp do + begin + PixelFormat := pf24bit; + Width := W; + Height := H; + Transparent := TRUE; + // TransparentMode := tmFixed; + TransparentColor := TRANS_COLOR; + + Canvas.CopyRect (Rect (0, 0, W, H), Bmp.Canvas, + MakeRect (BORDER_W, BORDER_H, W, H)); + end; + ClearEdge; + with VisualBmp.Canvas do + begin + Brush.Color := Background.Brush.Color; + FillRect (MakeRect (BORDER_W, BORDER_H, W, H)); + Draw (BORDER_W, BORDER_H, TmpBmp); + end; + + if OnionSkinTile <> -1 then + if not HideOnionSkin1.Checked then + begin + for tmpY1 := 0 to H - 1 do + for tmpX1 := 0 to W - 1 do + begin + newRGB := OnionSkinBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H]; + oldRGB := VisualBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H]; + if (newRGB <> TRANS_COLOR) and (oldRGB <> TRANS_COLOR) then + VisualBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H] := Blend (oldRGB, newRGB, 125, 50); + end; + end; + + if Drawing then + if DrawingShape then + begin + VisualBmp.Canvas.Pen := Bmp.Canvas.Pen; + VisualBmp.Canvas.Brush := Bmp.Canvas.Brush; + if Bmp.Canvas.Pen.Color = TRANS_COLOR then + begin + VisualBmp.Canvas.Pen.Color := Background.Brush.Color; + if VisualBmp.Canvas.Brush.Style <> bsClear then // 2.44: bug fix + VisualBmp.Canvas.Brush.Color := Background.Brush.Color; + end; + DrawFTShape (Origin.X, Origin.Y, CurPos.X, CurPos.Y, VisualBmp.Canvas); + DrawingShape := FALSE; + ClearEdge; + end; + + + if bHistoryShow.Down then + begin + for i := 0 to HistoryListBox.Items.Count - 1 do + if HistoryListBox.Selected[i] then + begin + tmpS := HistoryListBox.Items[i]; + if tmpS <> '' then + begin + tmpS := tmpS + ','; + for j := 1 to 4 do + begin + k := Pos (',', tmpS); + sNum := Copy (tmpS, 1, k - 1); + Delete (tmpS, 1, k); + case j of + 1: Val (sNum, tmpX1, iCode); + 2: Val (sNum, tmpY1, iCode); + 3: Val (sNum, tmpX2, iCode); + 4: Val (sNum, tmpY2, iCode); + end; + end; + VisualBmp.Canvas.Pixels[tmpX1 + BORDER_W, tmpY1 + BORDER_H] := $F808F8; + VisualBmp.Canvas.Pixels[tmpX2 + BORDER_W, tmpY2 + BORDER_H] := $F808F8; + + end; + end; + end; + + if UpdateAll then + with TileTab[Tab.TabIndex] do + begin + if (tbr.TileBitmap <> nil) and (tbr.Current < tbr.TileCount) then + begin + TileBitmap.Width := tbr.TileBitmap.Width; + TileBitmap.Height := tbr.TileBitmap.Height; + + // update the actual Tile Bitmap: + tbr.TileBitmap.Canvas.CopyRect (MakeRect (tbr.Current * W, 0, W, H), + TmpBmp.Canvas, Rect (0, 0, W, H)); + + + TileBitmap.Picture.Bitmap.Canvas.CopyRect + (MakeRect (tbr.Current * W, 0, W, H), + // TmpBmp.Canvas, Rect (0, 0, W, H)); + VisualBmp.Canvas, + MakeRect (BORDER_W, BORDER_H, W, H)); + end; +// TileBitmap.Picture.Bitmap := tbr.TileBitmap; + end; + + + with Pattern.Canvas do + begin + ov := TileTab[Tab.TabIndex].tbr.Overlap; + x := Pattern.Width div 2 - W div 2; + y := Pattern.Height div 2 - (H - ov) div 2; + + OfsX := 0; // 2.4 + OfsY := 0; + with TileTab[Tab.TabIndex].tbr do + begin + if Current < Length (OffsetX) then + OfsX := OffsetX[Current]; + if Current < Length (OffsetY) then + OfsY := OffsetY[Current]; + end; + + if UpdateAll or (OfsX <> 0) or (OfsY <> 0) then + begin + Brush.Color := Background.Brush.Color; + FillRect (MakeRect (0, 0, Width, Height)); + end; + + if (not Pattern1.Checked) or (not UpdateAll) then + begin + { if ov > 0 then } + Draw (x + OfsX, y + OfsY, TmpBmp); + TmpBmp.Canvas.CopyRect (Rect (0, ov, W, H - ov), VisualBmp.Canvas, + MakeRect (BORDER_W, BORDER_H + ov, W, H - ov)); + end + else + begin + Inc (x, OfsX); + Inc (y, OfsY); + + while x > 0 do + Dec (x, W); + while y > -ov do + Dec (y, H - ov); + + repeat + i := 0; + repeat + if ov > 0 then + Draw (x + i, y, TmpBmp); + Pattern.Canvas.CopyRect (MakeRect (x + i, y + ov, W, H - ov), + VisualBmp.Canvas, MakeRect (BORDER_W, BORDER_H + ov, W, H - ov)); + + Inc (i, W); + until x + i >= Pattern.Width; + Inc (y, H - ov); + until y >= Pattern.Height; + end; + end; + + Tile.Picture.Graphic := VisualBmp; + + // with TileTab[Tab.TabIndex].tbr do + // Tile.Canvas.Rectangle (Current * W, 0, Current * W + W, H); + + + TmpBmp.Free; + + with TileTab[Tab.TabIndex] do + begin + lastscale := Scale; + lastscrollpos := TileScrollBox.HorzScrollBar.Position; + BackGrColor := Background.Brush.Color; + end; + end; + + UpdateTileGrid; + +end; { UpdateBMP } + +procedure TMainForm.SetTileSize (Width, Height: Integer); + var + BW, BH: Integer; + i, j: Integer; +begin + // StatusBar.Panels[0].Text := Format ('Size: %d x %d', [Width, Height]); + W := Width; + H := Height; + with CursorImage do + begin + Picture.Bitmap.PixelFormat := pf24bit; + Picture.Bitmap.TransparentColor := clRed; + Picture.Bitmap.Transparent := True; + Width := W; + Height := H + 1; + Picture.Bitmap.Width := W; + Picture.Bitmap.Height := H + 1; + with Canvas do + begin + Brush.Color := clRed; // transparent color for cursor + Brush.Style := bsSolid; + Pen.Color := clRed; + Pen.Style := psSolid; + Rectangle (0, 0, W + 1, H + 2); + end; + end; + BW := W + 2 * BORDER_W; + BH := H + 2 * BORDER_H; + with Bmp do + begin + Width := BW; + Height := BH; + Transparent := TRUE; + TransparentMode := tmFixed; + TransparentColor := TRANS_COLOR; + with Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := TRANS_COLOR; + Pen.Style := psClear; + FillRect (Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H)); + Pen.Style := psSolid; + Pen.Color := Color.Brush.Color; + end; + end; + with TempBmp do + begin + Width := BW; + Height := BH; + end; + with VisualBmp do + begin + Width := BW; + Height := BH; + end; + with OnionSkinBmp do + begin + Width := BW; + Height := BH; + end; + + bmp1.Width := BW; + bmp1.Height := BH; + ResizeBitmap (bmp1); + + bmp2.Width := BW; + bmp2.Height := BH; + ResizeBitmap (bmp2); + + SelBmp.Width := BW; + SelBmp.Height := BH; + ResizeBitmap (SelBmp); + FillBitmap (SelBmp, TRANS_COLOR); + for j := 0 to BH - 1 do + for i := 0 to BW - 1 do + case (i + j) mod 8 of + 0: SelBmp.Picture.Bitmap.Canvas.Pixels[i, j] := clYellow; + 4: SelBmp.Picture.Bitmap.Canvas.Pixels[i, j] := clWhite; + end; + + UpdateBmp (TRUE); +end; + + +procedure TMainForm.SetFromTo (N: Integer); + var + R, G, B, iR, iG, iB, RR, GG, BB: Integer; + C, i, j: Integer; +begin + C := Color.Brush.Color; + GetRGB (C, R, G, B); + i := (255 div (MaxRGB - 1)); + R := R div i; + G := G div i; + B := B div i; + + if Pal256 and (FromToCount = -1) then + begin + j := Row256 * 8; + for i := 0 to MAX_FROM_TO - 1 do + begin + if i = MAX_FROM_TO - 1 then Dec (j); + GetRGB (PaletteValues[j + i], iR, iG, iB); + ExFromToList[i, 0] := iR; + ExFromToList[i, 1] := iG; + ExFromToList[i, 2] := iB; + FromToList[i] := PaletteValues[j + i]; + FromToFirst := Index256 mod 8; + FromToLast := Index256 mod 8; + end; + end + else + begin + case FromToCount mod 12 of + 1: begin RR := 3; GG := 3; BB := 3; end; + 2: begin RR := 2; GG := 2; BB := 2; end; + 3: begin RR := 2; GG := 2; BB := 1; end; + 4: begin RR := 1; GG := 2; BB := 2; end; + 5: begin RR := 2; GG := 1; BB := 2; end; + 6: begin RR := 2; GG := 1; BB := 1; end; + 7: begin RR := 1; GG := 2; BB := 1; end; + 8: begin RR := 1; GG := 1; BB := 2; end; + 9: begin RR := 2; GG := 2; BB := 4; end; + 10: begin RR := 4; GG := 2; BB := 2; end; + 11: begin RR := 2; GG := 4; BB := 2; end; + else begin RR := 4; GG := 4; BB := 4; end; + end; + + j := MAX_FROM_TO div 2; + + for i := -j to MAX_FROM_TO - j - 1 do + begin + iR := (256 div (MaxB - 1)) * (R + (RR * i) div 2); + iG := (256 div (MaxB - 1)) * (G + (GG * i) div 2); + iB := (256 div (MaxB - 1)) * (B + (BB * i) div 2); + ExFromToList[j + i, 0] := iR; + ExFromToList[j + i, 1] := iG; + ExFromToList[j + i, 2] := iB; + iR := LimitRGB (iR); + iG := LimitRGB (iG); + iB := LimitRGB (iB); + iR := ColorMatch (iR); + iG := ColorMatch (iG); + iB := ColorMatch (iB); + if (j + i) in [0..MAX_FROM_TO] then + FromToList[j + i] := RGB (LimitRGB (iR), LimitRGB (iG), LimitRGB (iB)); + end; + end; + + FromTo.Repaint; +end; + +procedure TMainForm.SetColor (NewColor: Integer; SetFT: Boolean; AddFT: Boolean); + var + i: Integer; + Found: Boolean; +begin + Background.Pen.Style := psClear; + Erasing := FALSE; + ShiftErasing := FALSE; + + if AddFT then + SetFT := FALSE; + + // don't remove palette when selecting a color with right mouse button + if UsedColors.Visible then + begin + Found := FALSE; + // is the new color in the palette? + with UsedColorsImage.Picture.Bitmap do + for i := 0 to Height - 1 do + if Canvas.Pixels[0, i] = NewColor then + Found := TRUE; + SetFT := not Found; + end; + + if SetFT then + begin + ShowRGB (NewColor); + if Color.Brush.Color <> NewColor then + FromToCount := 0 - Byte (Pal256); + FromToFirst := MAX_FROM_TO div 2; + FromToLast := MAX_FROM_TO div 2; + if FromToCount > 0 - Byte (Pal256) then + begin + FromToFirst := 0; + FromToLast := MAX_FROM_TO - 1; + end; + + HideUsedColors; // the new color is not in the palette + end; + Color.Pen.Style := psSolid; + Color.Brush.Color := NewColor; + + Bmp.Canvas.Pen.Color := NewColor; + DrawColor := NewColor; + FillColor := NewColor; + + if AddFT then // 2.51 - add colors to FT list + begin + if (FromToFirst = MAX_FROM_TO div 2) and + (FromToLast = MAX_FROM_TO div 2) then + begin + FromToFirst := MAX_FROM_TO - 1; + FromToLast := MAX_FROM_TO - 1; + FromToList[FromToFirst] := NewColor; + FromTo.Repaint; + end + else + if FromToFirst <= FromToLast then + if FromToList[FromToFirst] <> NewColor then + begin + if FromToFirst = 0 then + begin + if FromToLast < MAX_FROM_TO - 1 then + begin + Inc (FromToLast); + for i := MAX_FROM_TO - 1 downto FromToFirst + 1 do + FromToList[i] := FromToList[i - 1]; + end; + end + else + Dec (FromToFirst); + + FromToList[FromToFirst] := NewColor; + FromTo.Repaint; + end; + end; + + if SetFT then + begin + SetFromTo (FromToCount); + + i := FindCurrentColorPattern (NewColor, FALSE); + if i = -1 then + i := FindCurrentColorPattern (NewColor, TRUE); + Found := i > -1; + if Found then + begin + FromToSavePos := i; + SelectSavedFromToList; + + if FindCurrentColorPattern (NewColor, FALSE) = -1 then // to set the selection + FindCurrentColorPattern (NewColor, TRUE); + FromToPaint (nil); + end; + end; +end; + +procedure TMainForm.SetBackgroundColor (NewColor: Integer; Select: Boolean); +begin + if Select then + begin + ShowRGB (NewColor); + Background.Pen.Style := psSolid; + Color.Pen.Style := psClear; + + Bmp.Canvas.Pen.Color := TRANS_COLOR; + DrawColor := TRANS_COLOR; + FillColor := TRANS_COLOR; + + Erasing := TRUE; + end; + + TileTab[Tab.TabIndex].tbr.BackGr := NewColor; + + if UsedColors.Visible then + UsedColorsImage.Picture.Bitmap.Canvas.Pixels[0, 0] := NewColor; + + Background.Brush.Color := NewColor; +// TileScrollBox.Color := NewColor; + UpdateBmp (TRUE); + +{ + Tile.Color := NewColor; + DrawingBoard.Brush.Color := NewColor; +} + pBack.Color := BackGround.Brush.Color; + pMid.Color := BackGround.Brush.Color; + pFront.Color := BackGround.Brush.Color; + + UpdateTileBitmap; + Modified := TRUE; +end; + +procedure TMainForm.RearrangePalette1Click(Sender: TObject); +begin + PaletteOrder := (PaletteOrder + 1) mod MAX_PALETTE_ORDER; + Palette.Repaint; +end; + +procedure TMainForm.FromToPaint(Sender: TObject); + var + i, j, k, W, Y1, Y2, Y3, AH: Integer; + Split: Boolean; +begin + Split := SplitColorPattern1.Checked; + W := FromTo.Width div MAX_FROM_TO; + Y1 := 6; + Y2 := 20 - 4 * Byte (Split); + Y3 := 22; + AH := 2; + with FromTo.Canvas do + begin + Brush.Style := bsSolid; + for i := 0 to MAX_FROM_TO - 1 do + begin + Brush.Color := FromToList[i]; + Pen.Style := psClear; + Rectangle (i * W, Y1, (i + 1) * W + 1, Y2); + if Split then + begin + Brush.Color := OtherFromTo.FT[i]; + Rectangle (i * W, Y2, (i + 1) * W + 1, Y3); + end; + end; + Pen.Style := psSolid; + Brush.Style := bsClear; + Pen.Color := FromToPanel.Color; + Rectangle (0, AH, MAX_FROM_TO * W, AH + 1); + Pen.Color := clBlack; + i := FromToFirst * W; + j := FromToLast * W; + k := j + W - 2; + if i > j then + begin + j := FromToFirst * W; + i := FromToLast * W; + k := i + 2; + end; + Rectangle (i, AH, j + W, AH + 1); + if FromToFirst <> FromToLast then + Rectangle (k, AH - 1, k + 1, AH + 2); + end; + i := (FromToFirst + 1) * Byte (FromToFirst = FromToLast); + ToggleMultiple1.Checked := i = 0; + N_1.Checked := i = 1; + N_2.Checked := i = 2; + N_3.Checked := i = 3; + N_4.Checked := i = 4; + N_5.Checked := i = 5; + N_6.Checked := i = 6; + N_7.Checked := i = 7; + N_8.Checked := i = 8; + N_9.Checked := i = 9; +end; + +procedure TMainForm.FromToMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + W: Integer; +begin + W := FromTo.Width div MAX_FROM_TO; + if Button = mbLeft then + begin + FromToSelect := TRUE; + FromToFirst := X div W; + FromToLast := FromToFirst; + end; + if Button = mbRight then + FromToBackgroundSelect := TRUE; + FromToMouseMove (Sender, Shift, X, Y); +end; + +procedure TMainForm.FromToMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + var + W, n, k: Integer; +begin + W := FromTo.Width div MAX_FROM_TO; + n := X div W; + if (n >= 0) and (n < MAX_FROM_TO) then + begin + k := FromToList[n]; + ShowRGB (k); + if FromToSelect then + begin + SetColor (k, FALSE, FALSE); + FromToLast := X div W; + if FromToLast < 0 then + FromToLast := 0; + if FromToLast >= MAX_FROM_TO then + FromToLast := MAX_FROM_TO - 1; + FromTo.Repaint; + { + if (FromToSavePos < Length (FromToSave)) then + begin + FromToSave[FromToSavePos].F := FromToFirst; + FromToSave[FromToSavePos].L := FromToLast; + end; + } + end; + if FromToBackgroundSelect then + SetBackgroundColor (k, FALSE); + end; +end; + +procedure TMainForm.FromToMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + FromToSelect := FALSE; + if Button = mbRight then + FromToBackgroundSelect := FALSE; +end; + +procedure TMainForm.ColorMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + if Erasing then + SetColor (Color.Brush.Color, TRUE, FALSE) + else + begin + ColorDialog.Color := Color.Brush.Color; + if ColorDialog.Execute then + begin + ColorSelect := FALSE; + SetColor (ColorDialog.Color, FALSE, FALSE); + end; + ShowRGB (ColorDialog.Color); + end; + if Button = mbRight then + SetColor (ColorMatch (Color.Brush.Color), TRUE, FALSE); +end; + +procedure TMainForm.ZoomIn1Click(Sender: TObject); +begin + if Mode = mTile then + if Scale < MAX_SCALE then + begin + Inc (Scale); + MainForm.Resize; + end; + if Mode = mMap then + if Zoom > 1 then + begin + Dec (Zoom); + ZoomMap; + UpdateMap; + end; + if TileSelection.Visible then + ShowTileSelection (TRUE); +end; + +procedure TMainForm.ZoomOut1Click(Sender: TObject); +begin + if Mode = mTile then + if Scale > 1 then + begin + Dec (Scale); + MainForm.Resize; + end; + if Mode = mMap then + if Zoom < MAX_ZOOM then + begin + Inc (Zoom); + ZoomMap; + UpdateMap; + end; + if TileSelection.Visible then + ShowTileSelection (TRUE); +end; + +function IntStr (x: Integer): string; + var + bin: array[0..SizeOf (Integer) - 1] of Char absolute x; + s: string; + i: Integer; +begin + s := ''; + for i := 0 to SizeOf (Integer) - 1 do + s := s + bin[i]; + IntStr := s; +end; + +function StrInt (s: string): Integer; + var + x: Integer; + bin: array[0..SizeOf (Integer) - 1] of Char absolute x; + i: Integer; +begin + for i := 0 to SizeOf (Integer) - 1 do + bin[i] := s[i + 1]; + StrInt := x; +end; + +function ActName (dt: TDrawingTool): string; +begin + case dt of + dtBrush: ActName := 'Brush'; + dtLine: ActName := 'Line'; + dtRect, + dtFilledRect: ActName := 'Rectangle'; + dtRoundRect, + dtFilledRoundRect: ActName := 'Round Rectangle'; + dtEllipse, + dtFilledEllipse: ActName := 'Ellipse'; + dtFill: ActName := 'Flood Fill'; + else + ActName := 'Drawing'; + end; +end; + +procedure TMainForm.TileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + xp, yp: Integer; +begin + Busy := TRUE; + LastShift := Shift; + LastButton := Button; + GradientH := FALSE; + GradientV := FALSE; + GradientD := FALSE; + + Horizontal3.Enabled := TRUE; + Vertical3.Enabled := TRUE; + Diagonal1.Enabled := TRUE; + Horizontal3.Checked := FALSE; + Vertical3.Checked := FALSE; + Diagonal1.Checked := FALSE; + + LastX := X; + LastY := Y; + ShiftState := Shift; + xp := X div Scale; + yp := Y div Scale; + if (Button = mbLeft) then + begin + if DrawingTool in FirstSaveUndoTools then + SaveUndo (ActName (DrawingTool)); + if (ssShift in ShiftState) or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down then + SaveTempBmp; + Drawing := TRUE; + LineList := ''; + Bmp.Canvas.MoveTo (xp, yp); + Origin := Point (xp, yp); + CurPos := Origin; + OrigColor := Bmp.Canvas.Pixels[xp, yp]; + Bmp.Canvas.Pen.Color := DrawColor; + if Bmp.Canvas.Brush.Style = bsSolid then + Bmp.Canvas.Brush.Color := FillColor; + Modified := TRUE; + end; + if Button = mbRight then + if (ssShift in ShiftState) then + begin + SaveUndo ('Erase'); + ShiftErasing := TRUE; + Bmp.Canvas.MoveTo (xp, yp); + Origin := Point (xp, yp); + CurPos := Origin; + Bmp.Canvas.Pen.Color := TRANS_COLOR; + Modified := TRUE; + end + else + ReadingColor := TRUE; + if not (Erasing or ShiftErasing) then + if (ssShift in ShiftState) or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down then + begin + if DarkButton.Down then + SpecialColor := SPECIAL_COLOR1 + else + if LightButton.Down then + SpecialColor := SPECIAL_COLOR2 + else + SpecialColor := $FFFFFF - BackGround.Brush.Color and $FFFFFF; + Bmp.Canvas.Pen.Color := SpecialColor; + if Bmp.Canvas.Brush.Style = bsSolid then + Bmp.Canvas.Brush.Color := SpecialColor; + end; + TileMouseMove (Sender, Shift, X, Y); + Busy := FALSE; +end; + +procedure TMainForm.TileMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + i, j, k, l, m, n, o, p, xx, yy: Integer; + R, G, B, RR, GG, BB: Integer; + cm: Boolean; + Ex: Boolean; + RX, RY, NS: Real; + RndX, RndY: Integer; + +begin + Busy := TRUE; + LastShift := Shift; + LastButton := Button; + LastX := X; + LastY := Y; + Ex := FALSE; + if Button = mbLeft then + if Drawing then + begin + if not (DrawingTool in FirstSaveUndoTools) then + SaveUndo (ActName (DrawingTool)); + DrawFTShape (Origin.X, Origin.Y, CurPos.X, CurPos.Y, Bmp.Canvas); + SaveHistoryCoords (Origin.X - BORDER_W, Origin.Y - BORDER_H, CurPos.X - BORDER_W, CurPos.Y - BORDER_H); + Undo[UndoPos].HistoryCoords := HistoryListBox.Items[HistoryListBox.Items.Count - 1]; // 3.00 + AddColorPattern1Click (Sender); + Drawing := FALSE; + end; + if Button = mbRight then + begin + ReadingColor := FALSE; + ShiftErasing := FALSE; + end; + if (ssShift in ShiftState) or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down then + begin + l := 256 div (MaxRGB - 1); + + // NoiseSizeX := W div LineTool.Height; // 2.43 + // NoiseSizeY := H div LineTool.Height; + // if NoiseSizeX < 2 then NoiseSizeX := 2; + // if NoiseSizeY < 2 then NoiseSizeY := 2; + RndX := Random (1000); + RndY := Random (1000); + + if RandomButton.Down then + begin + for j := BORDER_H - 1 to BORDER_H + H + 1 do + for i := BORDER_W - 1 to BORDER_W + W + 1 do + with TempBmp.Canvas do + begin + RX := RndX + i * (15 - LineTool.Height); + RY := RndY + j * (15 - LineTool.Height); + NS := Noise2 (RX / W, RY / H); + + n := Abs (FromToLast - FromToFirst); + m := Byte (FromToLast > FromToFirst) - Byte (FromToFirst > FromToLast); + k := Pixels[i, j]; + if (n = 0) xor (ssCtrl in ShiftState) then + begin + if k <> TRANS_COLOR then + begin + GetRGB (k, R, G, B); + if ssShift in ShiftState then + begin + if UseOldNoiseFunctions1.Checked then + m := l * (Random (3) - 1) + else + m := Round (System.Int (l * (2 * NS - 1))) + end + else + m := 0; { smooth } + Pixels[i, j] := RGB (LimitRGB (R + m), LimitRGB (G + m), LimitRGB (B + m)); + end; + end + else + // Pixels[i, j] := FromToList[FromToFirst + m * Random (n + 1)]; + begin + Ex := TRUE; + if UseOldNoiseFunctions1.Checked then + p := FromToFirst + m * Random (n + 1) + else + p := Round (System.Int (FromToFirst + m * NS * (n + 1))); + R := ExFromToList[p, 0] div 4 + 96; + G := ExFromToList[p, 1] div 4 + 96; + B := ExFromToList[p, 2] div 4 + 96; + Pixels[i, j] := RGB (LimitRGB (R), LimitRGB (G), LimitRGB (B)); + end; + end; + end; + + for j := BORDER_H to BORDER_H + H do + for i := BORDER_W to BORDER_W + W do + begin + k := Bmp.Canvas.Pixels[i, j]; + if k = SpecialColor then + begin + k := TempBmp.Canvas.Pixels[i, j]; + if RandomButton.Down then + begin + if k <> TRANS_COLOR then + begin + n := 2 + 6 * Byte ((ssAlt in ShiftState) or (RealTimeLightening1.Checked)); + o := n; + GetRGB (k, RR, GG, BB); + RR := n * RR; + GG := n * GG; + BB := n * BB; + + for n := -1 to 1 do + for m := -1 to 1 do + begin + xx := i + m; + yy := j + n; + if xx < BORDER_W then + Inc (xx, W) + else if xx >= W + BORDER_W then + Dec (xx, W); + if yy < BORDER_H then + Inc (yy, H) + else if yy >= H + BORDER_H then + Dec (yy, H); + p := TempBmp.Canvas.Pixels[xx, yy]; + if p <> TRANS_COLOR then + begin + GetRGB (p, R, G, B); + Inc (RR, R); + Inc (GG, G); + Inc (BB, B); + Inc (o); + end; + end; + RR := RR div o; + GG := GG div o; + BB := BB div o; + if Ex then + begin + RR := (RR - 96) * 4; + GG := (GG - 96) * 4; + BB := (BB - 96) * 4; + end; + R := LimitRGB (RR); + G := LimitRGB (GG); + B := LimitRGB (BB); + k := RGB (R, G, B); + end; + end + else + begin + if k = TRANS_COLOR then + k := DrawColor + else + begin + if PlusButton.Down then + begin + if (ssAlt in ShiftState) or (RealTimeLightening1.Checked) then + k := ColorBetween (k, ColorBetween (k, ColorBetween (k, Color.Brush.Color))) + else + k := ColorBetween (k, Color.Brush.Color); + end + else + begin + p := 1 + 5 * Byte ((ssAlt in ShiftState) or (RealTimeLightening1.Checked)); + cm := k = ColorMatch (k); + GetRGB (k, R, G, B); + if LightButton.Down then + k := RGB (LimitRGB (R + l div p), LimitRGB (G + l div p), LimitRGB (B + l div p)) + else + k := RGB (LimitRGB (R - l div p), LimitRGB (G - l div p), LimitRGB (B - l div p)); + if cm and (p = 1) then + k := ColorMatch (k); + end; + end; + end; + Bmp.Canvas.Pixels[i, j] := k; + end; + end; + end; + + Horizontal3.Checked := FALSE; + Vertical3.Checked := FALSE; + Diagonal1.Checked := FALSE; + Horizontal3.Enabled := FALSE; + Vertical3.Enabled := FALSE; + Diagonal1.Enabled := FALSE; + + UpdateBmp (TRUE); + Busy := FALSE; +end; + +procedure TMainForm.TileMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + var + xp, yp, c: Integer; + i, j, k, l: Integer; +begin + Busy := TRUE; + LastShift := Shift; + LastX := X; + LastY := Y; + xp := X div Scale; + yp := Y div Scale; + + i := xp - BORDER_W; + j := yp - BORDER_H; + if (i >= 0) and (i < W) and + (j >= 0) and (j < H) then + ShowRGB (Bmp.Canvas.Pixels[xp, yp]) + else + ShowRGB (TRANS_COLOR); + + StatusBar.Panels[1].Text := Format ('(%d, %d)', [i, j]); + ShowOrigin := Drawing and (DrawingTool in [dtLine, dtRect, + dtRoundRect, dtEllipse, dtFilledRect, + dtFilledRoundRect, dtFilledEllipse, dtSelection]); + if ShowOrigin then + begin + k := Origin.x - BORDER_W; + l := Origin.y - BORDER_H; + StatusBar.Panels[1].Text := Format ('(%d, %d)-', [k, l]) + + StatusBar.Panels[1].Text + + Format (' [%d, %d]', [Abs (k - i), Abs (l - j)]); // 2.5 + end; + + if ReadingColor then + begin + { i := FromToFirst; + j := FromToLast; } + c := Bmp.Canvas.Pixels[xp, yp]; + if c = TRANS_COLOR then + SetBackgroundColor (Background.Brush.Color, TRUE) + else + begin + SetColor (c, TRUE, ssCtrl in LastShift); + { + if ssCtrl in LastShift then + begin + FromToFirst := i; // 2.2 + FromToLast := j; + FromToPaint (Sender); + end; } // 2.51 - removed, now use Ctrl to add to FT selection + end; + end; + + if Drawing then + begin + case DrawingTool of + dtFill: + begin + for i := -1 to W do + begin + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H - 1] := TRANS_COLOR; + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + H] := TRANS_COLOR; + end; + for j := -1 to H do + begin + Bmp.Canvas.Pixels[BORDER_W - 1, BORDER_H + j] := TRANS_COLOR; + Bmp.Canvas.Pixels[BORDER_W + W, BORDER_H + j] := TRANS_COLOR; + end; + + if ssCtrl in LastShift then // 2.53 - replace color in tile + begin + k := Bmp.Canvas.Pixels[xp, yp]; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + if Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] = k then + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := Bmp.Canvas.Pen.Color; + end + else + Bmp.Canvas.FloodFill (xp, yp, Bmp.Canvas.Pixels[xp, yp], fsSurface); + end; + dtPoint: + begin + Bmp.Canvas.Pixels[xp, yp] := Bmp.Canvas.Pen.Color; + Bmp.Canvas.LineTo (xp, yp); + CurPos := Point (xp, yp); + end; + dtBrush: + begin + if (ssAlt in ShiftState) or (FromToFirst = FromToLast) then + begin + Bmp.Canvas.Pixels[xp, yp] := Bmp.Canvas.Pen.Color; + Bmp.Canvas.LineTo (xp, yp); + end + else + DrawFTCircle (BMP.Canvas, xp, yp, ssShift in ShiftState); + if DrawingTool = dtBrush then + if (CurPos.x <> xp) or (CurPos.y <> y) or (LineList = '') then + LineList := LineList + IntStr (xp) + IntStr (yp); + CurPos := Point (xp, yp); + end; + else + begin + CurPos := Point (xp, yp); + DrawingShape := TRUE; + end; + end; + UpdateBmp (FALSE); + end; + if ShiftErasing then + begin + Bmp.Canvas.Pixels[xp, yp] := TRANS_COLOR; + Bmp.Canvas.LineTo (xp, yp); + CurPos := Point (xp, yp); + UpdateBmp (FALSE); + end; + Busy := FALSE; +end; + +procedure TMainForm.ShowTileSelection (Clip: Boolean); + var + X1, Y1, X2, Y2: Integer; +begin + X1 := TileSelX1; + Y1 := TileSelY1; + X2 := TileSelX2; + Y2 := TileSelY2; + + if Clip then + begin + if X1 - BORDER_W < 0 then X1 := BORDER_W; + if Y1 - BORDER_H < 0 then Y1 := BORDER_H; + if X2 - BORDER_W > W then X2 := W + BORDER_W; + if Y2 - BORDER_H > H then Y2 := H + BORDER_H; + + if X2 - BORDER_W < 0 then X2 := BORDER_W; + if Y2 - BORDER_H < 0 then Y2 := BORDER_H; + if X1 - BORDER_W > W then X1 := W + BORDER_W; + if Y1 - BORDER_H > H then Y1 := H + BORDER_H; + + TileSelX1 := X1; + TileSelY1 := Y1; + TileSelX2 := X2; + TileSelY2 := Y2; + end; + + with TileSelection do + begin + Left := X1 * Scale + Tile.Left; + Top := Y1 * Scale + Tile.Top; + Width := (X2 - X1) * Scale; + Height := (Y2 - Y1) * Scale; + Visible := TRUE; + end; +end; + + +procedure TMainForm.SwapInt (var x, y: Integer); + var + i: Integer; +begin + i := x; + x := y; + y := i; +end; + +function TMainForm.ColorPerc (RGB1, RGB2, Perc2, MaxPerc: Integer): Integer; + var + R1, G1, B1: Integer; + R2, G2, B2: Integer; + C: Integer; + Perc1: Integer; +begin + GetRGB (RGB1, R1, G1, B1); + GetRGB (RGB2, R2, G2, B2); + Perc1 := MaxPerc - Perc2; + C := MakePalRGB ((R1 * Perc1 + R2 * Perc2) div MaxPerc, + (G1 * Perc1 + G2 * Perc2) div MaxPerc, + (B1 * Perc1 + B2 * Perc2) div MaxPerc, 0); + ColorPerc := C; +end; + +function TMainForm.ColorPercFT (i1, i2, Perc2, MaxPerc: Integer): Integer; + var + Perc1: Integer; + N: Integer; + c1, c2, p1, p2: Integer; +begin + Perc1 := MaxPerc - Perc2; + if i1 > i2 then + begin + SwapInt (i1, i2); + SwapInt (Perc1, Perc2); + end; + Inc (Perc1); // 2.43 bug fix: range check error + + // MainForm.Caption := Format (' %d %d %d %d %d ', [i1, i2, perc1, perc2, maxperc]); + + N := i2 - i1; + c1 := i1 + N * Perc2 div MaxPerc; + c2 := c1 + 1; + p1 := (100 * N * Perc2 div MaxPerc) mod 100; + p2 := 100; + if (c1 < Low (FromToList)) then + c1 := Low (FromToList); + if (c2 > High (FromToList)) then + c2 := High (FromToList); + ColorPercFT := ColorPerc (FromToList[c1], FromToList[c2], p1, p2); +end; + +procedure TMainForm.DrawFTShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + var + i, j, k, l, M, N, o, p, x, y: Integer; + oi, pi: Integer; + OrigX1, OrigX2, OrigY1, OrigY2: Integer; + sh, alt, ctrl: Boolean; + found: Boolean; + OColor: Integer; + +begin + OrigX1 := X1; + OrigX2 := X2; + OrigY1 := Y1; + OrigY2 := Y2; + sh := ssShift in ShiftState; + alt := ssAlt in ShiftState; + ctrl := ssCtrl in ShiftState; + + if DrawingTool in [dtRect, dtRoundRect, dtEllipse, + dtFilledRect, dtFilledRoundRect, dtFilledEllipse] then + begin + if X2 >= X1 then Inc (X2) else Inc (X1); + if Y2 >= Y1 then Inc (Y2) else Inc (Y1); + end; + + with TileSelection do + if (DrawingTool in [dtSelection]) and + (not ((X1 = X2) and (Y1 = Y2))) then + begin + if X1 > X2 then begin i := X1; X1 := X2; X2 := i; end; + if Y1 > Y2 then begin i := Y1; Y1 := Y2; Y2 := i; end; + TileSelX1 := X1; + TileSelY1 := Y1; + TileSelX2 := X2; + TileSelY2 := Y2; + ShowTileSelection (TRUE); + end + else + Visible := FALSE; + + N := Byte (FromToLast > FromToFirst) - + Byte (FromToLast < FromToFirst); + if Erasing or + LightButton.Down or + DarkButton.Down or + PlusButton.Down or + RandomButton.Down or + (N = 0) or + (not (DrawingTool in [dtPoint, + dtBrush, + dtFilledRect, + dtFilledRoundRect, + dtFilledEllipse])) then + DrawShape (X1, Y1, X2, Y2, C) + else + begin + if X1 > X2 then begin i := X1; X1 := X2; X2 := i; end; + if Y1 > Y2 then begin i := Y1; Y1 := Y2; Y2 := i; end; + i := FromToFirst; + + if (DrawingTool in [dtPoint, dtBrush]) and Alt then { *** } + begin + M := Length (LineList) div (2 * SizeOf (Integer)); + + for j := 0 to M - 1 do + begin + + if SmoothPalette1.Checked then + begin + if Ctrl then + begin + OColor := OrigColor; + if OColor = TRANS_COLOR then + OColor := Background.Brush.Color; // 2.43 + o := ColorPerc (OColor, FromToList[FromToLast], j, M); + end + else + begin + oi := FromToFirst; + pi := FromToLast; + o := ColorPercFT (oi, pi, j, M); + end; + end + else + begin + if M - 1 = 0 then + i := FromToLast + else + i := FromToFirst + (j * Abs (FromToLast - FromToFirst) div (M - 1)) * N; + o := FromToList[i]; + end; + + C.Pen.Color := o; + C.Brush.Color := o; + + x := StrInt (Copy (LineList, 1, SizeOf (Integer))); + Delete (LineList, 1, SizeOf (Integer)); + y := StrInt (Copy (LineList, 1, SizeOf (Integer))); + Delete (LineList, 1, SizeOf (Integer)); + if j = 0 then + C.MoveTo (x, y) + else + C.LineTo (x, y); + end; + + end + else + if Ctrl or GradientH or GradientV or GradientD then + begin + if not (GradientH or GradientV or GradientD) then + GradientD := TRUE; + + SaveTempBmp; + + with TempBmp.Canvas do + begin + Pen.Color := SpecialColor; + Brush.Color := SpecialColor; + end; + + DrawShape (X1, Y1, X2, Y2, TempBmp.Canvas); + + k := 0; + l := 1; + for y := Y1 - 1 to Y2 + 1 do + for x := X1 - 1 to X2 + 1 do + begin + if TempBmp.Canvas.Pixels[x, y] = SpecialColor then + begin + TempBmp.Canvas.Pixels[x, y] := C.Pixels[x, y]; + if Ctrl then + begin + oi := -1; + o := C.Pixels[x, y]; + if o = TRANS_COLOR then + o := BackGround.Brush.Color; + end + else + begin + oi := FromToFirst; + o := FromToList[oi]; + end; + pi := FromToLast; + p := FromToList[pi]; + if GradientH then + begin + k := x - X1; + l := X2 - X1; + end; + if GradientV then + begin + k := y - Y1; + l := Y2 - Y1; + end; + if GradientD then + begin + if OrigX1 > OrigX2 then + k := Abs (X2 - x) + else + k := Abs (x - X1); + if OrigY1 > OrigY2 then + Inc (k, Abs (Y2 - y)) + else + Inc (k, Abs (y - Y1)); + l := Abs (X2 - X1) + Abs (Y2 - Y1); + end; + if (GradientH and (OrigX1 > OrigX2)) or + (GradientV and (OrigY1 > OrigY2)) then + begin + SwapInt (oi, pi); + SwapInt (o, p); + end; + if (oi >= 0) and (pi >= 0) then + begin + C.Pixels[x, y] := ColorPercFT (oi, pi, Abs (k), Abs (l)); + end + else + C.Pixels[x, y] := ColorPerc (o, p, Abs (k), Abs (l)); + end; + end; + + + end + else + repeat { draw filled shape (outside -> inside) } + if sh then + begin + C.Pen.Color := SpecialColor; + C.Brush.Color := SpecialColor; + SaveTempBmp; + end + else + begin + C.Pen.Color := FromToList[i]; + C.Brush.Color := FromToList[i]; + end; + DrawShape (X1, Y1, X2, Y2, C); + + if sh then + begin + for y := Y1 - LineTool.Height to Y2 + LineTool.Height do // 2.44 + for x := X1 - LineTool.Height to X2 + LineTool.Height do + begin + if Bmp.Canvas.Pixels[x, y] = SpecialColor then + begin + found := FALSE; + k := i; + repeat + if TempBmp.Canvas.Pixels[x, y] = FromToList[k] then + found := TRUE; + k := k + N; + until ((N < 0) and (k - N = 0)) + or ((N > 0) and (k - N = MAX_FROM_TO - 1)); + if not Found then + Bmp.Canvas.Pixels[x, y] := FromToList[i] + else + Bmp.Canvas.Pixels[x, y] := TempBmp.Canvas.Pixels[x, y]; + end; + + end; + end; + + // 2.44 + if not ((XShade < 0) and (i mod (3 - Abs (XShade)) = 0)) then + Inc (X1, LineTool.Height); + if not ((YShade < 0) and (i mod (3 - Abs (YShade)) = 0)) then + Inc (Y1, LineTool.Height); + if not ((XShade > 0) and (i mod (3 - Abs (XShade)) = 0)) then + Dec (X2, LineTool.Height); + if not ((YShade > 0) and (i mod (3 - Abs (YShade)) = 0)) then + Dec (Y2, LineTool.Height); + i := i + N; + until (X1 >= X2) or (Y1 >= Y2) or (i - N = FromToLast); + C.Pen.Color := Color.Brush.Color; + C.Brush.Color := Color.Brush.Color; + end; +end; + +procedure TMainForm.DrawFTCircle (C: TCanvas; xp, yp: Integer; Shift: Boolean); + var + x, y, x1, y1, x2, y2: Integer; + d: Real; + N: Integer; + i, k: Integer; + Found: Boolean; +begin + N := Byte (FromToLast > FromToFirst) - + Byte (FromToLast < FromToFirst); + + x1 := xp - C.Pen.Width; + y1 := yp - C.Pen.Width; + x2 := xp + C.Pen.Width; + y2 := yp + C.Pen.Width; + + for y := Y1 to Y2 do + for x := X1 to X2 do + begin + d := 1 + (Sqrt (Sqr (x - xp) + Sqr (y - yp))); + if d < (C.Pen.Width + 1) then + begin + d := 1 + (Sqrt (Sqr (x - xp - XShade) + Sqr (y - yp - YShade))); // 2.44 + if d > C.Pen.Width then + d := C.Pen.Width; + i := FromToFirst + N * (C.Pen.Width - Round (System.Int (d))); + if ((N < 0) and (i < FromToLast)) or + ((N > 0) and (i > FromToLast)) then + i := FromToLast; + + Found := FALSE; + k := i; + if N <> 0 then + repeat + if C.Pixels[x, y] = FromToList[k] then + Found := TRUE; + k := k + N; + until ((N < 0) and (k - N <= 0)) + or ((N > 0) and (k - N >= MAX_FROM_TO - 1)); + + if (Shift) or (not Found) then + C.Pixels[x, y] := FromToList[i]; + end; + end; + +end; + +procedure TMainForm.DrawShape (X1, Y1, X2, Y2: Integer; C: TCanvas); + var + DX, DY: Integer; + +begin + with C do + begin + case DrawingTool of + dtLine: + begin + MoveTo (X1, Y1); + LineTo (X2, Y2); + end; + dtRect, + dtFilledRect: + Rectangle (X1, Y1, X2, Y2); + dtRoundRect, + dtFilledRoundRect: + RoundRect (X1, Y1, X2, Y2, + (X1 - X2) div 2, (Y1 - Y2) div 2); + { Polybezier ([Point (X1, Y1), Point (X2, Y1), Point (X2, Y2), Point (X1, Y2)]); } + { Arc (X1, Y1, X2, Y2, curpos.X, curpos.Y, origin.X, origin.Y); } + { + begin + DX := X2 - X1; + DY := Y2 - Y1; + if CurPos.Y > Origin.Y then + if CurPos.X > Origin.X then + Polybezier ([Point (X1, Y1), Point (X2, Y1), Point (X2, Y2), Point (X1, Y1)]) + else + Polybezier ([Point (X2, Y1), Point (X1, Y1), Point (X1, Y2), Point (X2, Y1)]) + else + if CurPos.X > Origin.X then + Polybezier ([Point (X1, Y2), Point (X2, Y2), Point (X2, Y1), Point (X1, Y2)]) + else + Polybezier ([Point (X2, Y2), Point (X1, Y2), Point (X1, Y1), Point (X2, Y2)]) + + end; + } + + + dtEllipse, + dtFilledEllipse: + Ellipse (X1, Y1, X2, Y2); + end; + end; +end; + +procedure TMainForm.SetDrawingTool(Sender: TObject); +begin +{ + if DrawingTool = dtSelection then + begin + SaveUndo ('Drop Selection'); + UpdateBmp (TRUE); + Modified := TRUE; + end; +} + Bmp.Canvas.Brush.Style := bsClear; + + if Sender = SelectionButton then + ShowTileSelection (TRUE) + else + TileSelection.Visible := FALSE; + + if (Sender = PencilButton) or + (Sender = BrushButton) then + Tile.Cursor := crDefault + else + Tile.Cursor := crCross; + + LineSize[DrawingTool] := LineTool.Height; // 2.43 + + if (Sender = LineButton) or + (Sender = RectButton) or + (Sender = RoundRectButton) or + (Sender = EllipseButton) or + (Sender = BrushButton) then + begin + LineTool.Brush.Color := clBlack; + LineTool.Pen.Color := clBlack; + Bmp.Canvas.Pen.Width := LineTool.Height; + VisualBmp.Canvas.Pen.Width := LineTool.Height; + end + else + begin + LineTool.Brush.Color := clGray; + LineTool.Pen.Color := clGray; + Bmp.Canvas.Pen.Width := 1; + VisualBmp.Canvas.Pen.Width := 1; + end; + + if Sender = PencilButton then + DrawingTool := dtPoint + else + begin + if Sender = BrushButton then + DrawingTool := dtBrush + else + if Sender = LineButton then + DrawingTool := dtLine + else + if Sender = RectButton then + DrawingTool := dtRect + else + if Sender = RoundRectButton then + DrawingTool := dtRoundRect + else + if Sender = EllipseButton then + DrawingTool := dtEllipse + else + begin + Bmp.Canvas.Brush.Style := bsSolid; + Bmp.Canvas.Brush.Color := FillColor; + if Sender = FillButton then + DrawingTool := dtFill + else + if Sender = FilledRectButton then + DrawingTool := dtFilledRect + else + if Sender = FilledRoundRectButton then + DrawingTool := dtFilledRoundRect + else + if Sender = FilledEllipseButton then + DrawingTool := dtFilledEllipse + else + if Sender = SelectionButton then + DrawingTool := dtSelection; + end; + end; + + LineTool.Height := LineSize[DrawingTool]; // 2.43 + LineToolMouseDown(nil, mbMiddle, [], 0, 0); +end; + +procedure TMainForm.GetTileArea; +begin + TileAreaX := BORDER_W; + TileAreaY := BORDER_H; + TileAreaW := W; + TileAreaH := H; + if TileSelection.Visible then + begin + TileAreaX := TileSelX1; + TileAreaY := TileSelY1; + TileAreaW := TileSelX2 - TileSelX1; + TileAreaH := TileSelY2 - TileSelY1; + end; +end; + +procedure TMainForm.Up1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + for i := 0 to TileAreaW - 1 do + begin + y := TileAreaY; + k := Pixels[x, y]; + for j := 0 to TileAreaH - 2 do + Pixels[x, y + j] := Pixels[x, y + j + 1]; + Pixels[x, y + TileAreaH - 1] := k; + Inc (x); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.Down1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + for i := 0 to TileAreaW - 1 do + begin + y := TileAreaY; + k := Pixels[x, y + TileAreaH - 1]; + for j := TileAreaH - 1 downto 1 do + Pixels[x, y + j] := Pixels[x, y + j - 1]; + Pixels[x, y] := k; + Inc (x); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.Left1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + y := TileAreaY; + for j := 0 to TileAreaH - 1 do + begin + x := TileAreaX; + k := Pixels[x, y]; + for i := 0 to TileAreaW - 2 do + Pixels[x + i, y] := Pixels[x + i + 1, y]; + Pixels[x + TileAreaW - 1, y] := k; + Inc (y); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.Right1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + GetTileArea; + with Bmp.Canvas do + begin + y := TileAreaY; + for j := 0 to TileAreaH - 1 do + begin + x := TileAreaX; + k := Pixels[x + TileAreaW - 1, y]; + for i := TileAreaW - 1 downto 1 do + Pixels[x + i, y] := Pixels[x + i - 1, y]; + Pixels[x, y] := k; + Inc (y); + end; + end; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.HFlipBounds; + var + b1, b2: Boolean; +begin + if Bounds <> 0 then + begin + // if Bounds < $10 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + b1 := Bounds and $2 <> 0; + b2 := Bounds and $8 <> 0; + Bounds := Bounds and (not ($2 or $8)); + Bounds := Bounds or ((Byte(b1) shl 3) or (Byte(b2) shl 1)); + end + else + Bounds := Bounds xor 1; + BoundBox.RePaint; + Modified := TRUE; + end; +end; + +procedure TMainForm.RotateBounds (var Bounds: Integer; deg: Integer); // 2.5 + var + b0, b1, b2, b3: Boolean; +begin + if Bounds <> 0 then + begin + // if Bounds < $10 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + b0 := Bounds and $1 <> 0; + b1 := Bounds and $2 <> 0; + b2 := Bounds and $4 <> 0; + b3 := Bounds and $8 <> 0; + Bounds := Bounds and (not ($F)); + if deg > 0 then { rotate left } + Bounds := Bounds or (Byte(b0) shl 1) or (Byte(b1) shl 2) or (Byte(b2) shl 3) or (Byte(b3) shl 0) + else + Bounds := Bounds or (Byte(b0) shl 3) or (Byte(b1) shl 0) or (Byte(b2) shl 1) or (Byte(b3) shl 2); + end + else + Bounds := Bounds xor 1; { diagonal bounds, only 45 degrees so far } + BoundBox.RePaint; + Modified := TRUE; + end; +end; + +procedure TMainForm.Horizontal1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + SaveUndo ('Flip Horizontal'); + GetTileArea; + with Bmp.Canvas do + begin + y := TileAreaY; + for j := 0 to TileAreaH - 1 do + begin + x := TileAreaX; + for i := 0 to TileAreaW div 2 - 1 do + begin + k := Pixels[x + i, y]; + Pixels[x + i, y] := Pixels[x + TileAreaW - 1 - i, y]; + Pixels[x + TileAreaW - 1 - i, y] := k; + end; + Inc (y); + end; + end; + if not TileSelection.Visible then + HFlipBounds (Bounds); + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; +end; + +procedure TMainForm.VFlipBounds; + var + b1, b2: Boolean; +begin + if Bounds <> 0 then + begin + // if Bounds < $10 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + b1 := Bounds and $1 <> 0; + b2 := Bounds and $4 <> 0; + Bounds := Bounds and (not ($1 or $4)); + Bounds := Bounds or ((Byte(b1) shl 2) or (Byte(b2) shl 0)); + end + else + Bounds := Bounds xor 1; + BoundBox.RePaint; + Modified := TRUE; + end; +end; + +procedure TMainForm.Vertical1Click(Sender: TObject); + var + i, j, k, x, y: Integer; + b: Boolean; +begin + SaveUndo ('Flip Vertical'); + + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + for i := 0 to TileAreaW - 1 do + begin + y := TileAreaY; + for j := 0 to TileAreaH div 2 - 1 do + begin + k := Pixels[x, y + j]; + Pixels[x, y + j] := Pixels[x, y + TileAreaH - 1 - j]; + Pixels[x, y + TileAreaH - 1 - j] := k; + end; + Inc (x); + end; + end; + + if not TileSelection.Visible then + VFlipBounds (Bounds); + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; +end; + +procedure TMainForm.Clear1Click(Sender: TObject); + var + i, j: Integer; + b: Boolean; +begin + SaveUndo ('Clear'); + GetTileArea; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + Bmp.Canvas.Pixels[i + TileAreaX, j + TileAreaY] := TRANS_COLOR; + + b := UseAsAlphaChannel1.Enabled; + UseAsAlphaChannel1.Enabled := FALSE; + UpdateBmp (TRUE); + UseAsAlphaChannel1.Enabled := b; + + Modified := TRUE; +end; + +procedure TMainForm.LineToolMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Button = mbLeft then + if LineTool.Height < 12 then + LineTool.Height := LineTool.Height + 1; + if Button = mbRight then + if LineTool.Height > 1 then + LineTool.Height := LineTool.Height - 1; + LineTool.Top := LineToolPanel.Height div 2 - (LineTool.Height + 1) div 2; + if DrawingTool = dtPoint then + begin + Bmp.Canvas.Pen.Width := 1; + VisualBmp.Canvas.Pen.Width := 1; + end + else + begin + Bmp.Canvas.Pen.Width := LineTool.Height; + VisualBmp.Canvas.Pen.Width := LineTool.Height; + end; +end; + +procedure TMainForm.Pattern1Click(Sender: TObject); +begin + Pattern1.Checked := not Pattern1.Checked; + UpdateBmp (TRUE); +end; + + +procedure TMainForm.ImportTiles1Click(Sender: TObject); + var + BlockW, BlockH, + SkipX, SkipY, + SkipW, SkipH: Integer; + ai: array of Integer; + i: Integer; + Unique: Boolean; +begin + + if OpenPictureDialog.Execute then + begin + ImportTiles.Result := FALSE; + ImportTiles.ShowModal; + if ImportTiles.Result then + begin + with ImportTiles do + begin + BlockW := TileWidth.Value; + BlockH := TileHeight.Value; + SkipX := ClipLeft.Value; + SkipY := ClipTop.Value; + SkipW := HorzSpace.Value; + SkipH := VertSpace.Value; + Unique := RemoveDuplicates.Checked; + + if (BlockW >= 4) and (BlockH >= 4) and + (SkipX >= 0) and (SkipY >= 0) and + (SkipW >= 0) and (SkipH >= 0) then + begin + + CreateNewTileCollection (Identifier.Text, BlockW, BlockH, TRUE); + + SetLength (ai, Length (TransList)); + for i := 0 to Length (ai) - 1 do + ai[i] := TransList[i]; + (* + with TileTab[Tab.TabIndex] do + if tbr.TileBitmap <> nil then + tbr.TileBitmap.Free; + *) + FreeTBR (TileTab[Tab.TabIndex].tbr); + + MainForm.ProgressPanel.Visible := TRUE; + + TileTab[Tab.TabIndex].tbr := + ReadTileBitmap (OpenPictureDialog.Filename, + BlockW, BlockH, TransX, TransY, + ai, + SkipX, SkipY, + SkipW, SkipH, + ProgressBar, + FALSE, + Unique, + FALSE, + TileTab[Tab.TabIndex].tbr); + + TileTab[Tab.TabIndex].tbr.BackGr := BackGround.Brush.Color; + + SetLength (ai, 0); + + MainForm.ProgressPanel.Visible := FALSE; + end + else + ShowMessage ('Invalid parameters.'); + end; + + TabChange (Sender); + Modified := TRUE; + end; + end; + UpdateTileBitmap; +end; + +procedure TMainForm.DrawCursor; + var + L, C: Integer; + + procedure Rct (Canvas: TCanvas; X, Y, W, H: Integer); + begin + Canvas.Rectangle (X, Y, X + W, Y + H); + end; + +begin + C := CursorSize; + with TileTab[Tab.TabIndex] do + begin + with CursorImage do + begin + L := tbr.Current * W - TileScrollBox.HorzScrollBar.ScrollPos; + + while (L < 0) and (TileScrollBox.HorzScrollBar.Position >= W) do + begin + TileScrollBox.HorzScrollBar.Position := TileScrollBox.HorzScrollBar.Position - W; + L := tbr.Current * W - TileScrollBox.HorzScrollBar.ScrollPos; + end; + if L < 0 then + TileScrollBox.HorzScrollBar.Position := 0; + + while L > TileScrollBox.Width - W do + begin + TileScrollBox.HorzScrollBar.Position := TileScrollBox.HorzScrollBar.Position + W; + L := tbr.Current * W - TileScrollBox.HorzScrollBar.ScrollPos; + end; + Left := L; + Top := 0; + with Canvas do + begin + Pen.Color := clBlack; + Pen.Style := psSolid; + Brush.Color := clWhite; + Brush.Style := bsSolid; + end; + + Rct (Canvas, 0, 0, C, C); + Rct (Canvas, W div 2 - C div 2, 0, C, C); + Rct (Canvas, W - C, 0, C, C); + Rct (Canvas, 0, H div 2 - C div 2, C, C); + Rct (Canvas, W - C, H div 2 - C div 2, C, C); + Rct (Canvas, 0, H - C, C, C); + Rct (Canvas, W div 2 - C div 2, H - C, C, C); + Rct (Canvas, W - C, H - C, C, C); + end; + end; + + TileSelection.Visible := FALSE; + +end; + +procedure TMainForm.ShowStatusInfo; + var + b: Boolean; + OfsX, OfsY: Integer; +begin + if Tab.TabIndex > -1 then + with TileTab[Tab.TabIndex] do + begin + StatusBar.Panels[3].Text := Format ('Tile %d of %d', [tbr.Current + 1, tbr.TileCount]); + + with StatusBar.Panels[5] do // 2.4 + begin + with tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + begin + OfsX := tbr.OffsetX[tbr.Current]; + OfsY := tbr.OffsetY[tbr.Current]; + Text := Format ('(%d, %d)', [OfsX, OfsY]); + end + else + Text := ''; + if Text = '(0, 0)' then + Text := ''; + end; + end; + + if Mode = mTile then + begin + StatusBar.Panels[0].Text := Format ('Size: %d x %d', [W, H]); + + Copy1.Enabled := TRUE; + Cut1.Enabled := TRUE; + Delete1.Enabled := TRUE; + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + RandomFill1.Enabled := FALSE; + ClearArea1.Enabled := FALSE; + MapScrollFunction1.Enabled := FALSE; + ReplaceSelectedTile1.Enabled := FALSE; + + RemoveMap1.Enabled := FALSE; + MapProperties1.Enabled := FALSE; + end; + + Copy1.Caption := 'Copy'; + + if Mode = mMap then + begin + with TileTab[Tab.TabIndex].tbr.Maps do // 2.53 + begin + NextMap1.Enabled := Length (aMaps) > 0; + PreviousMap1.Enabled := Length (aMaps) > 0; + MoveMapLeft1.Enabled := (Length (aMaps) > 0) and // 2.55 + (CurMap > 0); + MoveMapRight1.Enabled := (Length (aMaps) > 0) and // 2.55 + (CurMap < Length (aMaps) - 1); + + ScaledPaste1.Enabled := FALSE; + end; + + if lmp <> nil then + StatusBar.Panels[0].Text := Format ('Size: %d x %d', [CurMapW, CurMapH]) + else + StatusBar.Panels[0].Text := ''; + + // StatusBar.Panels[1].Text := Format ('(%d, %d)', [i, j]); + // StatusBar.Panels[1].Text := Format ('(%d, %d)-', [i, j]) + + // StatusBar.Panels[1].Text; + + Copy1.Enabled := true; // { bug: } (ClipTab.TabIndex > -1); // Selection; // 2.54 copy current tile + if not Selection then Copy1.Caption := 'Copy Tile Combination'; + + Cut1.Enabled := Selection; + Delete1.Enabled := Selection or (ClipTab.TabIndex > -1); + + ConverttoTileSequence1.Enabled := Selection; + InsertTileSequence1.Enabled := Selection; + RemoveTileSequence1.Enabled := SeqTab.TabIndex > -1; + ReplaceCurrentTileSequence1.Enabled := Selection and (SeqTab.TabIndex > -1); + + b := Selection and (ClipTab.TabIndex > -1); + Paste1.Enabled := b; + StretchPaste1.Enabled := b; + RandomFill1.Enabled := b; + ClearArea1.Enabled := b; + ReplaceSelectedTile1.Enabled := b; + + RemoveMap1.Enabled := MapTab.TabIndex > -1; + MapProperties1.Enabled := MapTab.TabIndex > -1; + MapScrollFunction1.Enabled := MapTab.TabIndex > -1; + + end; + + UtilsTab.Visible := (Mode = mTile); + + b := (Mode = mMap) and (MapTab.TabIndex > -1); + InsertHorizontal1.Enabled := b; + InsertVertical1.Enabled := b; + DeleteHorizontal1.Enabled := b; + DeleteVertical1.Enabled := b; + ImportMap1.Enabled := b; + ExportMap1.Enabled := b; + + ShowMapLayer1.Enabled := b; // 2.54 + + ReplaceColorUnderCursor1.Enabled := (Mode = mTile); +end; + +procedure TMainForm.StartEdit (UpdateAll: Boolean); +begin + if Length (TileTab) > 0 then + with TileTab[Tab.TabIndex] do + begin + if tbr.TileCount = 0 then + begin + CreateNewTile (tbr); + UpdateTileBitmap; + end; + + if UpdateAll then + begin + // TileBitmap.Width := tbr.TileCount * tbr.W; + // TileBitmap.Height := tbr.H; + + // TileBitmap.Picture.Bitmap := tbr.TileBitmap; + + // TileScrollBox.HorzScrollBar.Range := TileBitmap.Width; + TileScrollBox.HorzScrollBar.Increment := tbr.W; + TilePanel.Height := + tbr.H + + 16 // (TileScrollBox.Height - TileScrollBox.ClientHeight) + + (Tab.TabHeight) + + StatusBar.Height + + 10; + end; + + if Mode = mTile then + begin + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + tbr.TileBitmap.Canvas, MakeRect (tbr.Current * W, 0, W, H)); + + Tile.Transparent := FALSE; + Tile.Stretch := TRUE; + Tile.Picture.Graphic := VisualBmp; + + Bounds := GetBound (tbr, -1); + end; + + TileMouseMove (nil, [], LastX, LastY); + + BoundBox.RePaint; + DrawCursor; + + if UpdateAll then + MainForm.Resize; + + if Mode = mTile then + begin + ClearUndo; + if not UpdateAll then + UpdateBmp (TRUE); + end + else + ShowStatusInfo; + end; +end; + + +procedure TMainForm.NewTile1Click(Sender: TObject); +begin + UpdateBmp (TRUE); + AllowMultEmptyTiles := Sender = NewTile1; + CreateNewTile (TileTab[Tab.TabIndex].tbr); + AllowMultEmptyTiles := FALSE; + UpdateTileBitmap; + StartEdit (TRUE); + + Modified := TRUE; +end; + +procedure TMainForm.TileBitmapMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + var i, j: Integer; +begin + if Button = mbRight then + begin + if OnionSkinTile = X div W then + OnionSkinTile := -1 + else + begin + OnionSkinTile := X div W; + with TileTab[Tab.TabIndex] do + OnionSkinBmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + tbr.TileBitmap.Canvas, MakeRect (OnionSkinTile * W, 0, W, H)); + end; + UpdateBMP (TRUE); + Exit; + end; + OnionSkinTile := -1; + + if Sender = TileBitmap then + TileTab[Tab.TabIndex].tbr.Current := X div W; + + if Mode = mMap then + if Button = mbLeft then + begin + SelectCurrentTile (TileTab[Tab.TabIndex].tbr.Current); + DrawCurrentTile; + end; + + StartEdit (TRUE); +end; + +function TMainForm.ColorMatch (C: Integer): Integer; + var + R, G, B: Integer; + rr, gg, bb: Integer; + i, j, k, l: Integer; +begin + GetRGB (C, R, G, B); + + if Pal256 and (CountEnabledColors > 0) then + begin + + k := -1; + l := -1; + for i := 0 to 255 do + if Enable256[i] then + begin + GetRGB (PaletteValues[i], rr, gg, bb); + j := sqr ((r - rr) * 2) + sqr ((g - gg) * 2) + sqr ((b - bb) * 2); + if (k = -1) or (j < l) then + begin + k := i; + l := j; + end; + end; + ColorMatch := PaletteValues[k]; + Exit; + + end + else + + if ShowCurrentPalette1.Checked then + with UsedColorsImage.Picture.Bitmap do + if Height > 1 then + begin + k := -1; + l := -1; + for i := 0 to Height - 1 do + begin + GetRGB (Canvas.Pixels[0, i], rr, gg, bb); + j := sqr ((r - rr) * 2) + sqr ((g - gg) * 2) + sqr ((b - bb) * 2); + if (k = -1) or (j < l) then + begin + k := i; + l := j; + end; + end; + ColorMatch := Canvas.Pixels[0, k]; + Exit; + end; + + i := 128 div (MaxRGB - 1); + j := 255 div (MaxRGB - 1); + + R := LimitRGB ((R + i) div j * j); + G := LimitRGB ((G + i) div j * j); + B := LimitRGB ((B + i) div j * j); + + Inc (R, R div 64); + Inc (G, G div 64); + Inc (B, B div 64); + + if R > 255 then R := 255; + if G > 255 then G := 255; + if B > 255 then B := 255; + + c := RGB (R, G, B); + if c = TRANS_COLOR then + c := TRANS_COLOR_REPLACEMENT; + + ColorMatch := c; +end; + +procedure TMainForm.MatchColors1Click(Sender: TObject); + var + i, j, k, x, y: Integer; +begin + GetTileArea; + SaveUndo ('Match Colors'); + for j := 0 to TileAreaH do + for i := 0 to TileAreaW do + begin + x := TileAreaX + i; + y := TileAreaY + j; + k := Bmp.Canvas.Pixels[x, y]; + if k <> TRANS_COLOR then + Bmp.Canvas.Pixels[x, y] := ColorMatch (k); + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.SwapWithUndo; + var + ur: UndoRec; +begin + ur.Bmp := TBitmap.Create; + SetStretchBltMode(ur.Bmp.Canvas.Handle, HALFTONE); + ur.Bmp.PixelFormat := pf24bit; + ur.Bmp.Width := W; + ur.Bmp.Height := H; + ur.Bmp.Canvas.CopyRect (Rect (0, 0, W, H), + Undo[UndoPos].Bmp.Canvas, Rect (0, 0, W, H)); + ur.ActionName := Undo[UndoPos].ActionName; + + Undo[UndoPos].Bmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + Undo[UndoPos].ActionName := Action; + + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + ur.Bmp.Canvas, Rect (0, 0, W, H)); + Action := ur.ActionName; + ur.Bmp.Free; + Modified := TRUE; +end; + +procedure TMainForm.Undo1Click(Sender: TObject); +begin +// UndoButton.Down := FALSE; + if not Undo1.Enabled then + Exit; + + if Undo[UndoPos].HistoryCoords <> '' then + HistoryListBox.Items.Delete(HistoryListBox.Items.Count - 1); + + SwapWithUndo; + + if UndoPos = 0 then + begin + Undo1.Caption := '&Undo'; + Undo1.Enabled := FALSE; + { + UndoButton.Down := FALSE; + UndoButton.Enabled := FALSE; + } + end + else + Undo1.Caption := '&Undo ' + Undo[UndoPos - 1].ActionName; + + Redo1.Caption := '&Redo ' + Action; + Redo1.Enabled := TRUE; +{ + RedoButton.Enabled := TRUE; +} + Dec (UndoPos); + + UpdateBmp (TRUE); +end; + +procedure TMainForm.Redo1Click(Sender: TObject); +begin +// RedoButton.Down := FALSE; + if not Redo1.Enabled then + Exit; + + Inc (UndoPos); + + SwapWithUndo; + + if Undo[UndoPos].HistoryCoords <> '' then + HistoryListBox.Items.Add(Undo[UndoPos].HistoryCoords); + + if UndoPos = UndoCount - 1 then + begin + Redo1.Caption := '&Redo'; + Redo1.Enabled := FALSE; + { + RedoButton.Down := FALSE; + RedoButton.Enabled := FALSE; + } + end + else + Redo1.Caption := '&Redo ' + Action; + + Undo1.Caption := '&Undo ' + Undo[UndoPos].ActionName; + Undo1.Enabled := TRUE; +{ + UndoButton.Enabled := TRUE; +} + UpdateBmp (TRUE); +end; + +procedure TMainForm.SaveTempBmp; +begin + TempBmp.Canvas.CopyRect (Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H), + Bmp.Canvas, Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H)); +end; + +procedure TMainForm.Copy1Click(Sender: TObject); + var + n, i, j: Integer; +begin + if Mode = mTile then + begin + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + i := TileSelX2 - TileSelX1; + j := TileSelY2 - TileSelY1; + ClipBmp.Width := i; + ClipBmp.Height := j; + ClipBmp.Canvas.CopyRect (Rect (0, 0, i, j), + Bmp.Canvas, MakeRect (TileSelX1, TileSelY1, i, j)); + ClipBoard.Assign (ClipBmp); + TileSelection.Visible := FALSE; + end + else + begin + ClipBmp.Width := W; + ClipBmp.Height := H; + ClipBmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + ClipBoard.Assign (ClipBmp); + end; + ScaledPaste1.Enabled := TRUE; + end; + if Mode = mMap then + begin + if not Selection then + begin + ClipBmp.Width := W; + ClipBmp.Height := H; + ClipBmp.Canvas.CopyRect (Rect (0, 0, W, H), + bmpPreview.Canvas, MakeRect (0, 0, W, H)); + ClipBoard.Assign (ClipBmp); // 2.54 + Exit; + end; + + with Area do + begin + ClipW := Right - Left + 1; + ClipH := Bottom - Top + 1; + NewClipMap (TileTab[Tab.TabIndex].tbr, ClipW, ClipH); + end; + n := ClipTab.Tabs.Count; + + ClipTab.TabIndex := ClipTab.Tabs.Add (IntToStr (n)); + + clip := SelectClipMap (TileTab[Tab.TabIndex].tbr, n); + with Area do + for j := Top to Bottom do + for i := Left to Right do + clip^.Map[j - Top, i - Left] := lmp^.Map[j, i]; + + ClipTabChange (Sender); + + Selection := FALSE; + UpdateMapRegion(Area); + + end; + Paste1.Enabled := TRUE; + StretchPaste1.Enabled := TRUE; +end; + + +procedure TMainForm.Paste1Click(Sender: TObject); + var + i, j, k: Integer; + x, y: Integer; + X1, Y1, X2, Y2: Integer; +begin + if Mode = mTile then + if Clipboard.HasFormat(CF_BITMAP) then + begin + SaveUndo ('Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + + with ClipBmp do + begin + X1 := 0; + Y1 := 0; + X2 := W; + Y2 := H; + + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + X1 := TileSelX1 - BORDER_W; + Y1 := TileSelY1 - BORDER_H; + X2 := TileSelX2 - BORDER_W - 1; + Y2 := TileSelY2 - BORDER_H - 1; + end; + + // Bmp.Canvas.Draw(BORDER_W, BORDER_H, ClipBmp); + for j := Y1 to Y2 do + for i := X1 to X2 do + begin + x := i - X1; + y := j - Y1; + if (x < ClipBmp.Width) and (y < ClipBmp.Height) then + begin + k := ClipBmp.Canvas.Pixels[x, y]; + if k <> TRANS_COLOR then + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := k; + end; + end; + end; + TileSelection.Visible := FALSE; + UpdateBmp (TRUE); + end; + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + y := (j - Top) mod ClipH; + x := (i - Left) mod ClipW; + lmp^.Map[j, i] := clip^.Map[y, x]; + end; + Selection := FALSE; + UpdateMapRegion(Area); + end; + Modified := TRUE; +end; + +procedure TMainForm.Delete1Click(Sender: TObject); + var + i, j: Integer; +begin + if Mode = mTile then + begin + if TileSelection.Visible then + begin + SaveUndo ('Clear'); + + for j := TileSelY1 to TileSelY2 - 1 do + for i := TileSelX1 to TileSelX2 - 1 do + Bmp.Canvas.Pixels[i, j] := TRANS_COLOR; + + TileSelection.Visible := FALSE; + UpdateBmp (TRUE); + Modified := TRUE; + end + else + begin + + ClearUndo; // bugfix + + UpdateBmp (TRUE); + // Clear1Click (Sender); + with TileTab[Tab.TabIndex] do + begin + i := CountTileUsed (tbr); + if i > 0 then + if MessageDlg ('Tile is used ' + IntToStr (i) + + ' time(s). Remove anyway?', mtWarning, + [mbOk, mbCancel], 0) = mrCancel then + Exit; + RemoveTile (tbr); + if tbr.TileCount = 0 then + CreateNewTile (tbr); + UpdateTileBitmap; + end; + Modified := TRUE; + StartEdit (TRUE); + end; + end; + + if Mode = mMap then + begin + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + ClearMCR (lmp^.Map[j, i]); + Modified := TRUE; + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end + else + if ClipTab.TabIndex > -1 then + begin + RemoveClip (TileTab[Tab.TabIndex].tbr, ClipTab.TabIndex); + with ClipTab do + begin + j := TabIndex; + Tabs.Delete (TabIndex); + for i := j to Tabs.Count - 1 do + Tabs.Strings[i] := IntToStr (StrToInt (Tabs.Strings[i]) - 1); + + if j <= Tabs.Count - 1 then + TabIndex := j + else + TabIndex := Tabs.Count - 1; + end; + ClipTabChange (Sender); + Modified := TRUE; + end + else + SelectCurrentTile (-1); + + Delete1.Enabled := Selection or (ClipTab.TabIndex > -1); + end; + +end; + +procedure TMainForm.Cut1Click(Sender: TObject); + var + Sel, TSel: Boolean; +begin + Sel := Selection; + TSel := TileSelection.Visible; + Copy1Click (Sender); + if Sel then + Selection := TRUE; + if TSel then + TileSelection.Visible := TRUE; + Delete1Click (Sender); +end; + +procedure TMainForm.MoveTileLeftClick(Sender: TObject); +begin + UpdateBmp (TRUE); + if MoveLeft (TileTab[Tab.TabIndex].tbr, TRUE) then + begin + // TileBitmap.Picture.Bitmap := TileTab[tab.TabIndex].tbr.TileBitmap; + UpdateTileBitmap; + DrawCursor; + Modified := TRUE; + end; + // StartEdit; + ShowStatusInfo; +end; + +procedure TMainForm.MoveTileRightClick(Sender: TObject); +begin + UpdateBmp (TRUE); + if MoveRight (TileTab[Tab.TabIndex].tbr, TRUE) then + begin + // TileBitmap.Picture.Bitmap := TileTab[tab.TabIndex].tbr.TileBitmap; + UpdateTileBitmap; + DrawCursor; + Modified := TRUE; + end; + // StartEdit; + ShowStatusInfo; +end; + +procedure TMainForm.RemoveDuplicateTiles1Click(Sender: TObject); +begin + ProgressPanel.Visible := TRUE; + Tiles.RemoveDuplicates (TileTab[Tab.TabIndex].tbr, ProgressBar); + StartEdit (TRUE); + ProgressPanel.Visible := FALSE; + UpdateTileBitmap; + Modified := TRUE; +end; + +procedure TMainForm.ShowRGB (color: Integer); + const + LastColor: Integer = -1; + var + R, G, B: Integer; + cR, cG, cB: Char; +begin + ColorUnderMousePointer := color; // 3.0 + cR := 'r'; cG := 'g'; cB := 'b'; + if color <> LastColor then + begin + GetRGB (color, R, G, B); + if color <> ColorMatch (color) then + begin cR := 'R'; cG := 'G'; cB := 'B'; end; + if color = TRANS_COLOR then + StatusBar.Panels[2].Text := 'Transparent' + else + StatusBar.Panels[2].Text := Format ('%s: %d, %s: %d, %s: %d', + [cR, R, cG, G, cB, B]); + LastColor := color; + end; +end; + +procedure TMainForm.ColorMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); +begin + ShowRGB (Color.Brush.Color); +end; + +procedure TMainForm.BackGroundMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); +begin + ShowRGB (TRANS_COLOR); +end; + +procedure TMainForm.About1Click(Sender: TObject); +begin + AboutForm.WebSite.Caption := URL; + AboutForm.ShowModal; +end; + +procedure TMainForm.Homepage1Click(Sender: TObject); + var + Param: string; +begin + Param := URL; + ShellExecute (0, 'open', PChar (Param), Nil, Nil, SW_SHOWNORMAL); +end; + +procedure TMainForm.ExportTiles1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + begin + if tbr.TileCount = 0 then + Exit; + + ExportTiles.ShowModal; + + with ExportTiles do + if Result then + begin + SavePictureDialog.DefaultExt := GraphicExtension(TBitmap); + SavePictureDialog.FileName := tbr.Filename; + if SavePictureDialog.Execute then + begin + ProgressPanel.Visible := TRUE; + WriteTileBitmap (SavePictureDialog.FileName, + MaxWidth.Value, + TransColor.Brush.Color, + BorderColor.Brush.Color, + Between.Value, Between.Value, + Edge.Value, Edge.Value, + tbr, + ProgressBar, + TransBottomRight.Checked, + FALSE, + SavePictureDialog.FilterIndex); + ProgressPanel.Visible := FALSE; + end; + end; + + end; +end; + +procedure TMainForm.DrawBounds (c: TCanvas; X, Y, Wid, Ht, lw, Bounds, Color: Integer); + var + X1, Y1, X2, Y2: Integer; + W, H, HW, HH: Integer; + MirV: Integer; +begin + with c do + begin + Pen.Style := psSolid; + Pen.Color := Color; + Pen.Width := lw; + + X1 := X + 1 + lw div 2; + Y1 := Y + 1 + lw div 2; + X2 := X + Wid - 1 - X1 - Byte (lw = 1); + Y2 := Y + Ht - 1 - Y1 - Byte (lw = 1); + W := X2 - X1; + H := Y2 - Y1; + HW := W div 2; + HH := H div 2; + + if Bounds <> 0 then + // if Bounds and $70 = 0 then + if ShortInt (Bounds) > 0 then + begin + { horizontal and vertical } + + if (Bounds and $1 = 1) then + begin + MoveTo (X1, Y1); + LineTo (X2, Y1); + Pixels[X2, Y1] := Color; + end; + if (Bounds and $2 = 2) then + begin + MoveTo (X1, Y1); + LineTo (X1, Y2); + Pixels[X1, Y2] := Color; + end; + if (Bounds and $4 = 4) then + begin + MoveTo (X1, Y2); + LineTo (X2, Y2); + Pixels[X2, Y2] := Color; + end; + if (Bounds and $8 = 8) then + begin + MoveTo (X2, Y1); + LineTo (X2, Y2); + Pixels[X2, Y2] := Color; + end; + + end + else + begin + { diagonal } + + MirV := 0; + if Bounds and $1 = $1 then + MirV := X2 - X1; + + case (Bounds and $3F) shr 1 of + 0: begin MoveTo (X2 - MirV, Y1); LineTo (X1 + MirV, Y2); end; + 1: begin MoveTo (X1 + HW, Y1); LineTo (X1 + MirV, Y2); end; + 2: begin MoveTo (X2 - MirV, Y1); LineTo (X2 - HW, Y2); end; + 3: begin MoveTo (X1 + MirV, Y2); LineTo (X2 - MirV, Y2 - HH); end; + 4: begin MoveTo (X1 + MirV, Y1 + HH); LineTo (X2 - MirV, Y1); end; + + end; + + end; + + end; +end; + +procedure TMainForm.BoundBoxPaint(Sender: TObject); + const + LastBounds: Integer = 0; + var + i, j, b: Integer; +begin + if Tab.TabIndex = -1 then + Exit; + + if Bounds = LastBounds then + if (Mode = mMap) and Selection then + Exit; // quick fix for strange bug: select area in map, set diagonal bound, keeps refreshing + + with BoundBox.Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := clBtnFace; + Pen.Style := psClear; + FillRect (Rect (0, 0, Width, Height)); + end; + DrawBounds (BoundBox.Canvas, 0, 0, BoundBox.Width, BoundBox.Height, 3, Bounds, clBlack); + + if Mode = mTile then + with BoundBox.Canvas do + begin + Pen.Style := psSolid; + Pen.Width := 1; + Pen.Color := clGray; + Brush.Style := bsClear; + i := BoundBox.Width div 2; + i := i + XShade * i div 3; + j := BoundBox.Height div 2; + j := j + YShade * j div 3; + Ellipse (i - 5, j - 5, i + 5, j + 5); + end; + + if Mode = mTile then + SetBound (TileTab[Tab.TabIndex].tbr, Bounds) + else + if TileTab[Tab.TabIndex].tbr.mcr.Bounds and (not $40) <> Bounds and (not $40) then + begin + TileTab[Tab.TabIndex].tbr.mcr.Bounds := + ShortInt ((TileTab[Tab.TabIndex].tbr.mcr.Bounds and $40) or (Bounds and (not $40))); + ShowSelectedTile; + end; + + if (Mode = mMap) and Selection then + if Bounds <> LastBounds then + begin + // if Bounds < $10 then + // if Bounds and $70 = 0 then + if ShortInt (Bounds) > 0 then // 2.55 + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + b := lmp^.Map[j, i].Bounds and (not $40); + if b > $F then + b := 0; + if (Bounds and 1) <> (LastBounds and 1) then + b := (b and (not 1)) or ((Bounds and 1) * (Byte (j = Area.Top))); + if (Bounds and 2) <> (LastBounds and 2) then + b := (b and (not 2)) or ((Bounds and 2) * (Byte (i = Area.Left))); + if (Bounds and 4) <> (LastBounds and 4) then + b := (b and (not 4)) or ((Bounds and 4) * (Byte (j = Area.Bottom))); + if (Bounds and 8) <> (LastBounds and 8) then + b := (b and (not 8)) or ((Bounds and 8) * (Byte (i = Area.Right))); + lmp^.Map[j, i].Bounds := (lmp^.Map[j, i].Bounds and $40) or ShortInt (b); + end; + // Selection := FALSE; + + UpdateMapRegion(Area); + Modified := TRUE; + + end + else + begin + + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + b := lmp^.Map[j, i].Bounds and (not $40); + if ((Bounds = $81) and (i - Area.Left = j - Area.Top)) or + ((Bounds = $80) and (Area.Right - i = j - Area.Top)) then + b := Bounds; +{ + b := lmp^.Map[j, i].Bounds; + if (Bounds and 1) <> (LastBounds and 1) then + b := (b and (not 1)) or ((Bounds and 1) * (Byte (j = Area.Top))); + if (Bounds and 2) <> (LastBounds and 2) then + b := (b and (not 2)) or ((Bounds and 2) * (Byte (i = Area.Left))); + if (Bounds and 4) <> (LastBounds and 4) then + b := (b and (not 4)) or ((Bounds and 4) * (Byte (j = Area.Bottom))); + if (Bounds and 8) <> (LastBounds and 8) then + b := (b and (not 8)) or ((Bounds and 8) * (Byte (i = Area.Right))); +} + lmp^.Map[j, i].Bounds := (lmp^.Map[j, i].Bounds and $40) or ShortInt (b); + end; + // Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + + end; + end; + + LastBounds := Bounds; +end; + +procedure TMainForm.Top1Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $1 + else + Bounds := $1; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.Bottom1Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $4 + else + Bounds := $4; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.Left2Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $2 + else + Bounds := $2; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.Right2Click(Sender: TObject); +begin + if Bounds and $80 = 0 then + Bounds := Bounds xor $8 + else + Bounds := $8; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.DiagonalUp1Click(Sender: TObject); +begin + if Bounds = $80 then + Bounds := $00 + else + Bounds := $80; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.DiagonalDown1Click(Sender: TObject); +begin + if Bounds = $81 then + Bounds := $00 + else + Bounds := $81; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.ClearAll1Click(Sender: TObject); +begin + Bounds := 0; + BoundBox.RePaint; + Modified := TRUE; +end; + +procedure TMainForm.BoundBoxMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + var + xx, yy: Boolean; +begin + Dec (X, BoundBox.Width div 2); + Dec (Y, BoundBox.Height div 2); + xx := Abs (X) >= BoundBox.Width div 4; + yy := Abs (Y) >= BoundBox.Height div 4; + + if (ssShift in Shift) then + begin + XShade := X div (BoundBox.Width div 5); + YShade := Y div (BoundBox.Height div 5); + BoundBox.Repaint; + end + else + begin + if xx and yy then + if X * Y < 0 then + DiagonalUp1Click (Sender) + else + DiagonalDown1Click (Sender) + else if xx then + begin + if X > 0 then + Right2Click (Sender) + else + Left2Click (Sender); + end + else if yy then + begin + if Y > 0 then + Bottom1Click (Sender) + else + Top1Click (Sender); + end + else + ClearAll1Click (Sender); + end; +end; + +procedure TMainForm.NewTileCollection1Click(Sender: TObject); +begin + with NewForm do + begin + NewMode := nmNewTileSet; + DefaultName := NewTCName; + CanChangeSize := TRUE; + DefaultOverlap := 0; + ShowModal; + if Result then + begin + if TileWidth.Value < 1 then TileWidth.Value := 1; // 2.4 + if TileHeight.Value < 1 then TileHeight.Value := 1; + + CreateNewTileCollection (Identifier.Text, TileWidth.Value, TileHeight.Value, TRUE); + TabChange (Sender); + TileTab[Tab.TabIndex].tbr.Overlap := Overlap.Value; + TileTab[Tab.TabIndex].tbr.SkipExport := Skip.Checked; // 2.2 + Modified := TRUE; + end; + end; +end; + +procedure TMainForm.CreateNewTileCollection (Name: string; BW, BH: Integer; AddNew: Boolean); + var + cr: Integer; +begin + if AddNew then + begin + cr := Length (TileTab); + SetLength (TileTab, cr + 1); + Tab.Tabs.Add (Name); + Tab.TabIndex := cr; + end; + + SetTileSize (BW, BH); + + TileTab[Tab.TabIndex].id := Name; + + Scale := DEFAULT_SCALE - BW div 8 + 4 - BH div 8 + 4; + if Scale < 1 then Scale := 1; + while (Scale * (BW + 2 * BORDER_W) < ScrollBox.ClientWidth) and + (Scale * (BH + 2 * BORDER_H) < ScrollBox.ClientHeight - 2 * BH) do + Inc (Scale); + + if Scale > MAX_SCALE then Scale := MAX_SCALE; + with TileTab[Tab.TabIndex] do + begin + lastscale := Scale; + lastscrollpos := 0; + AnimStart := -1; + AnimEnd := -1; + BackGrColor := Background.Brush.Color; + end; + + TileTab[Tab.TabIndex].tbr := CreateNewTBR (BW, BH); + + CreateNewTile (TileTab[Tab.TabIndex].tbr); + UpdateTileBitmap; + + DrawCursor; +end; + +function TMainForm.NewTCName: string; + var + Name: string; + i: Integer; +begin + i := 0; + repeat + Inc (i); + Name := 'Tiles' + IntToStr (i); + until Tab.Tabs.IndexOf (Name) = -1; + NewTCName := Name; +end; + +function TMainForm.NewMapName: string; + var + Name: string; + i: Integer; +begin + i := 0; + repeat + Inc (i); + Name := 'Map' + IntToStr (i); + until MapTab.Tabs.IndexOf (Name) = -1; + NewMapName := Name; +end; + +procedure TMainForm.Properties1Click(Sender: TObject); + var + OldW, OldH, NewW, NewH: Integer; +begin + with NewForm do + begin + NewMode := nmTileSetProperties; + DefaultName := TileTab[Tab.TabIndex].id; + CanChangeSize := HasNoTiles (TileTab[Tab.TabIndex].tbr); + OldW := TileTab[Tab.TabIndex].tbr.W; + OldH := TileTab[Tab.TabIndex].tbr.H; + TileWidth.Value := OldW; + TileHeight.Value := OldH; + + Skip.Checked := TileTab[Tab.TabIndex].tbr.SkipExport; // 2.2 + + DefaultOverlap := TileTab[Tab.TabIndex].tbr.Overlap; + ShowModal; + if Result then + with TileTab[Tab.TabIndex] do + begin + id := Identifier.Text; + Tab.Tabs.Strings[Tab.TabIndex] := Identifier.Text; + tbr.Overlap := Overlap.Value; + + if TileWidth.Value < 1 then TileWidth.Value := 1; // 2.4 + if TileHeight.Value < 1 then TileHeight.Value := 1; + + NewW := TileWidth.Value; + NewH := TileHeight.Value; + + tbr.SkipExport := Skip.Checked; // 2.2 + + if (NewW <> OldW) or (NewH <> OldH) then + begin + CreateNewTileCollection (Identifier.Text, NewW, NewH, FALSE); + + MainForm.Resize; + StartEdit (TRUE); + end; + SetEditorMode (mTile); + Modified := TRUE; + end; + end; +end; + +function TMainForm.TCNameOK (s: string; MayExist: Boolean): Boolean; + var + i: Integer; +begin + if Tab.Tabs.IndexOf (s) <> -1 then + TCNameOK := MayExist and (Tab.Tabs.IndexOf (s) = Tab.TabIndex) + else + begin + TCNameOK := FALSE; + if s = '' then + Exit; + if not (UpCase (s[1]) in ['A'..'Z']) then + Exit; + for i := 1 to Length (s) do + if not (UpCase (s[i]) in ['A'..'Z', '0'..'9', '_']) then + Exit; + TCNameOK := TRUE; + end; +end; + +procedure TMainForm.IdError (id: string); +begin + if id = '' then + MessageDlg ('An identifier is required.', mtError, [mbOk], 0) + else + if TCNameOk (id, TRUE) and (Tab.Tabs.IndexOf (id) <> Tab.TabIndex) then // 2.33 and ipv or + MessageDlg ('The name already exists.', mtError, [mbOk], 0) + else + MessageDlg ('The identifier "' + id + '" contains invalid characters.', mtError, [mbOk], 0); +end; + +procedure TMainForm.TabChange(Sender: TObject); + var + Cur: Integer; +begin +// UpdateBmp (TRUE); + +// if Mode <> mTile then +// SetEditorMode (mTile); + + with TileTab[Tab.TabIndex] do + begin + Cur := tbr.Current; + Background.Brush.Color := BackGrColor; + TileScrollBox.HorzScrollBar.Position := lastscrollpos; + Scale := lastscale; + tbr.Current := tbr.TileCount; // avoid clearing current tile + + SetTileSize (tbr.W, tbr.H); + + tbr.Current := Cur; + end; + + UpdateTileBitmap; + + + // MainForm.ScrollBox.SetFocus; + if Mode = mMap then + begin + MapDisplay.Visible := FALSE; + SetEditorMode (mMap); + end; + + StartEdit (TRUE); + HideUsedColors; +end; + +procedure TMainForm.Toolbar1Click(Sender: TObject); +begin + + Toolbar1.Checked := not Toolbar1.Checked; + ToolBar.Visible := Toolbar1.Checked; + MainForm.Resize; +end; + +procedure TMainForm.ActualSize1Click(Sender: TObject); +begin + if Mode = mTile then + begin + Scale := 1; + MainForm.Resize; + end; + if Mode = mMap then + begin + Zoom := ZOOM_FACTOR; + ZoomMap; + UpdateMap; + end; +end; + +procedure TMainForm.FitinWindow1Click(Sender: TObject); + var + WinW, WinH, iw, ih: Integer; +begin + WinW := ScrollBox.Width - 4; + WinH := ScrollBox.Height - 4; + iw := W + 2 * BORDER_W; + ih := H + 2 * BORDER_H; + Scale := 2; + while (iw * Scale < WinW) and (ih * Scale < WinH) + and (Scale <= MAX_SCALE) do + Inc (Scale); + Dec (Scale); + MainForm.Resize; +end; + +procedure TMainForm.SetPaletteDepth(Sender: TObject); +begin + if Sender = N61 then MaxRGB := 6 else + if Sender = N71 then MaxRGB := 7 else + if Sender = N81 then MaxRGB := 8 else + if Sender = N91 then MaxRGB := 9 else + MaxRGB := 10; + N61.Checked := MaxRGB = 6; + N71.Checked := MaxRGB = 7; + N81.Checked := MaxRGB = 8; + N91.Checked := MaxRGB = 9; + N101.Checked := MaxRGB = 10; + MaxR := MaxRGB; MaxG := MaxRGB; MaxB := MaxRGB; + if SmoothPalette1.Checked then + SmoothPalette1Click (Sender) + else + Palette.Repaint; +end; + +procedure TMainForm.DuplicateTile1Click(Sender: TObject); + var + TempBmp: TBitmap; + bnd: Integer; +begin + bnd := Bounds; + UpdateBmp (TRUE); + TempBmp := TBitmap.Create; + TempBmp.PixelFormat := pf24bit; + SetStretchBltMode(TempBmp.Canvas.Handle, HALFTONE); + with TempBmp do + begin + Width := W; + Height := H; + Canvas.CopyRect (Rect (0, 0, W, H), Bmp.Canvas, + MakeRect (BORDER_W, BORDER_H, W, H)); + end; + CreateNewTile (TileTab[Tab.TabIndex].tbr); + UpdateTileBitmap; +// StartEdit; + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + TempBmp.Canvas, Rect (0, 0, W, H)); + Bounds := bnd; + BoundBox.RePaint; + UpdateBmp (TRUE); + DrawCursor; + TempBmp.Free; + Modified := TRUE; +end; + +procedure TMainForm.SetBrightness(Sender: TObject); + var + N: Integer; +begin + if Sender = N_1 then N := 0 else + if Sender = N_2 then N := 1 else + if Sender = N_3 then N := 2 else + if Sender = N_4 then N := 3 else + if Sender = N_5 then N := 4 else + if Sender = N_6 then N := 5 else + if Sender = N_7 then N := 6 else + if Sender = N_8 then N := 7 else + N := 8; + FromToFirst := N; + FromToLast := N; + SetColor (FromToList[N], FALSE, FALSE); + FromTo.Repaint; +end; + +procedure TMainForm.PaletteDblClick(Sender: TObject); +begin +{ IgnorePaletteMouseDown := TRUE; + ColorDialog.Color := Color.Brush.Color; + if ColorDialog.Execute then + begin + ColorSelect := FALSE; + SetColor (ColorDialog.Color, FALSE, FALSE); + end; + ShowRGB (ColorDialog.Color); +} +end; + +procedure TMainForm.SetEditorMode (NewMode: TEditorMode); + var + TW, TH: Integer; + const + SPC_W = 3; + SPC_H = 3; + + procedure Arrange (var p: TPanel; + var bmp: TImage; + var spm: TSpeedButton; + var spu: TSpeedButton; + var spr: TSpeedButton; // 2.5 + n: Integer); + begin + with p do + begin + Left := 4 + n * (TW + 2); + Width := TW; + Height := TH; + end; + spu.Top := p.Top + p.Height + SPC_H + 2; + spm.Top := spu.Top; + spr.Top := spu.Top; + spu.Left := p.Left + p.Width div 3; + spm.Left := spu.Left - spm.Width; + spr.Left := spu.Left + spm.Width; + + with bmp do + begin + Left := SPC_W + BMFCenterAdd; + Top := SPC_H; + Width := W; + Height := H; + end; + ResizeBitmap (bmp); + FillBitmap (bmp, TRANS_COLOR); + bmp.Picture.Bitmap.TransparentColor := TRANS_COLOR; + end; + + var + i: Integer; + +begin { SetEditorMode - switch Tile/Map mode } + Mode := NewMode; + + ShowUsedColors1.Enabled := Mode = mTile; + ShowCurrentPalette1.Enabled := Mode = mTile; + + ShowUsedColorPatterns1.Enabled := Mode = mTile; + + TileSelection.Visible := FALSE; + + ShiftState := []; + + for i := 0 to StatusBar.Panels.Count - 1 do + StatusBar.Panels[i].Text := ''; + + if Mode = mMap then + begin + AnimationTimer.Enabled := False; + + MapTab.Tabs.Clear; + ClipTab.Tabs.Clear; + SeqTab.Tabs.Clear; + + + with TileTab[Tab.TabIndex] do + begin + for i := 0 to Length (tbr.Maps.aMaps) - 1 do + MapTab.Tabs.Add (tbr.Maps.aMaps[i].id); + MapTab.TabIndex := tbr.Maps.CurMap; + + for i := 0 to Length (tbr.Clip.aMaps) - 1 do + ClipTab.Tabs.Add (IntToStr (i)); + ClipTab.TabIndex := tbr.Clip.CurMap; + + for i := 0 to Length (tbr.Seq.aMaps) - 1 do + SeqTab.Tabs.Add (IntToStr (i)); + SeqTab.TabIndex := tbr.Seq.CurMap; + + Selection := FALSE; + Area := Rect (0, 0, 0, 0); + end; + + ScrollBox.Align := alNone; + ScrollBox.Visible := FALSE; + + ToolPanel.Visible := FALSE; + + UsedColors.Visible := FALSE; + PatternPanel.Visible := FALSE; + ColorsPanel.Visible := FALSE; + PalettePanel.Visible := FALSE; + + + CurTilePanel.Visible := TRUE; + TilePartsPanel.Visible := TRUE; + + TH := H + 2 * SPC_H; + TW := (RightPanelWidth - 12) div 3; + if TW < (W + 2 * SPC_W) then + TW := (W + 2 * SPC_W); + BMFCenterAdd := (TW - (W + 2 * SPC_W)) div 2; + + RightPanel.Width := 3 * TW + 12; + CurTilePanel.Height := TH + H + 10; + TilePartsPanel.Height := TH + 8 + bMir.Height + 2 * SPC_H; + + Arrange (pBack, bmpBack, bMir, bUps, bRot, 0); + Arrange (pMid, bmpMid, mMir, mUps, mRot, 1); + Arrange (pFront, bmpFront, fMir, fUps, fRot, 2); + + pPreview.Width := W + 2 * SPC_W; + pPreview.Height := H + 2 * SPC_H; + ResizeBitmap (bmpPreview); + bmpPreview.Left := SPC_W; + bmpPreview.Top := SPC_H; + bmpPreview.Width := 2 * W; + bmpPreview.Height := 2 * H; + bmpPreview.Stretch := TRUE; + pPreview.Width := 2 * W + 2 * SPC_W; + pPreview.Height := 2 * H + 2 * SPC_H; + pPreview.Top := 6; + pPreview.Left := CurTilePanel.Width div 2 - pPreview.Width div 2; + + ShowSelectedTile; + + MapToolPanel.Visible := TRUE; + ExtraPanel.Align := alBottom; + ExtraPanel.Height := 100; + ExtraPanel.Align := alTop; + + SeqTab.Align := alBottom; + SeqTab.Visible := TRUE; + SeqTab.Height := H + 2 * SPC_H + 32; + + ClipTab.Align := alClient; + ClipTab.Visible := TRUE; + + MapTab.Align := alClient; + MapTab.Visible := TRUE; + + Bounds := TileTab[Tab.TabIndex].tbr.mcr.Bounds; + BoundBox.Hint := 'Bounds'; + + SelectCurrentTile (TileTab[Tab.TabIndex].tbr.Current); + DrawCurrentTile; + end + else + if Mode = mTile then + begin + SeqTimer.Enabled := FALSE; + + + ClipTab.Align := alNone; + ClipTab.Visible := FALSE; + SeqTab.Align := alNone; + SeqTab.Visible := FALSE; + MapTab.Align := alNone; + MapTab.Visible := FALSE; + + + TilePartsPanel.Visible := FALSE; + CurTilePanel.Visible := FALSE; + + + RightPanel.Width := RightPanelWidth; + PalettePanel.Visible := TRUE; + ColorsPanel.Visible := TRUE; + PatternPanel.Visible := TRUE; + + ToolPanel.Visible := TRUE; + + ScrollBox.Align := alClient; + ScrollBox.Visible := TRUE; + + ExtraPanel.Height := 65; + MapToolPanel.Visible := FALSE; + + UsedColors.Visible := ShowUsedColors1.Checked or + ShowCurrentPalette1.Checked; + ColorPatternsPanel.Visible := ShowUsedColorPatterns1.Checked; + + if Length (TileTab) > 0 then + Bounds := GetBound (TileTab[Tab.TabIndex].tbr, -1) + else + Bounds := 0; + BoundBox.Hint := 'Default Bounds'; + end; + + Up1.Enabled := Mode = mTile; // 2.53 + Down1.Enabled := Mode = mTile; + Left1.Enabled := Mode = mTile; + Right1.Enabled := Mode = mTile; + + SelectNextClip1.Enabled := Mode = mMap; + SelectPreviousClip1.Enabled := Mode = mMap; + + FirstFrame1.Enabled := Mode = mTile; + LastFrame1.Enabled := Mode = mTile; + NextFrame1.Enabled := Mode = mTile; + PreviousFrame1.Enabled := Mode = mTile; + Animate1.Enabled := Mode = mTile; + Faster1.Enabled := Mode = mTile; + Default1.Enabled := Mode = mTile; + Slower1.Enabled := Mode = mTile; + + Pattern1.Enabled := Mode = mTile; + FitInWindow1.Enabled := Mode = mTile; + + RemoveTileSet1.Enabled := Mode = mTile; + + SaveCurrentTile1.Enabled := Mode = mTile; + ExportMapAsImage1.Enabled := Mode = mMap; + + SetGridGuidelines1.Enabled := Mode = mMap; + + NewTile1.Enabled := Mode = mTile; + Clear1.Enabled := Mode = mTile; + MatchColors1.Enabled := Mode = mTile; + ReplaceColors1.Enabled := Mode = mTile; + SplitColorPattern1.Enabled := Mode = mTile; + Move1.Enabled := Mode = mTile; + DuplicateTile1.Enabled := Mode = mTile; + Flip1.Enabled := Mode = mTile; + + ToggleMultiple1.Enabled := Mode = mTile; + N_1.Enabled := Mode = mTile; + N_2.Enabled := Mode = mTile; + N_3.Enabled := Mode = mTile; + N_4.Enabled := Mode = mTile; + N_5.Enabled := Mode = mTile; + N_6.Enabled := Mode = mTile; + N_7.Enabled := Mode = mTile; + N_8.Enabled := Mode = mTile; + N_9.Enabled := Mode = mTile; + RearrangePalette1.Enabled := Mode = mTile; + N61.Enabled := Mode = mTile; + N71.Enabled := Mode = mTile; + N81.Enabled := Mode = mTile; + N91.Enabled := Mode = mTile; + N101.Enabled := Mode = mTile; + + ConverttoTileSequence1.Enabled := FALSE; + InsertTileSequence1.Enabled := FALSE; + RemoveTileSequence1.Enabled := FALSE; + ReplaceCurrentTileSequence1.Enabled := FALSE; + + FlipCurrentTile1.Enabled := Mode = mMap; + SelectBackMidFront1.Enabled := Mode = mMap; + SelectCurrentTile1.Enabled := Mode = mMap; + + ShowGrid1.Enabled := Mode = mMap; + ShowMapCodes1.Enabled := Mode = mMap; + ShowBounds1.Enabled := Mode = mMap; + ClearArea1.Enabled := Mode = mMap; + + Properties1.Enabled := TRUE; +// MapProperties1.Enabled := Mode = mMap; + + DrawingInMap := FALSE; + ReadingFromMap := FALSE; + + // MapEditor1.Checked := Sender = MapEditor1; + // TileEditor1.Checked := Sender = TileEditor1; + + + ShowTileGrid1.Enabled := Mode = mTile; + + ClearUndo; + + if Mode = mTile then + begin + StartEdit (TRUE); + + AnimationTimer.Enabled := Animate1.Checked; + end + else + begin + MapTabChange (nil); + ClipTabChange (nil); + SeqTabChange (nil); + end; + + + if Mode = mTile then + begin + MoveMapLeft1.Enabled := FALSE; // 2.53 + MoveMapRight1.Enabled := FALSE; + NextMap1.Enabled := FALSE; + PreviousMap1.Enabled := FALSE; + end; + + + MapModeButton.Down := Mode = mMap; + MapModeButton.Enabled := Mode <> mMap; + TileModeButton.Down := Mode = mTile; + TileModeButton.Enabled := Mode <> mTile; + + + UndoButton.Visible := Mode = mTile; + RedoButton.Visible := Mode = mTile; + ToolButton3.Visible := Mode = mTile; + + NewTileButton.Visible := Mode = mTile; + ColorMatchButton.Visible := Mode = mTile; + ReplaceColorsButton.Visible := Mode = mTile; + ToolButton5.Visible := Mode = mTile; + + AnimateButton.Visible := Mode = mTile; + + ShowStatusInfo; + + ShowMapLayer1.Enabled := Mode = mMap; // 2.54 + if Mode = mMap then + begin + ShowBackLayer.Checked := TRUE; + ShowMidLayer.Checked := TRUE; + ShowFrontLayer.Checked := TRUE; + end; + + // 3.00 + //HistoryPanel.Enabled := Mode = mTile; + HistoryPanel.Visible := Mode = mTile; + +end; + +procedure TMainForm.BackgroundColor1Click(Sender: TObject); +begin + ColorDialog.Color := Background.Brush.Color; + if ColorDialog.Execute then + begin + SetBackgroundColor (ColorDialog.Color, FALSE); + if (Mode = mMap) and (MapTab.TabIndex <> -1) then + MapTabChange (Sender); + end; +end; + +procedure TMainForm.CopyTiles1Click(Sender: TObject); + var + i, j: Integer; + ovr, str, scaler, bnds: Boolean; +begin + with CopyTilesForm do + begin + Src.Text := TileTab[Tab.TabIndex].id; + Src.Items := Tab.Tabs; + Dst.Text := TileTab[Tab.TabIndex].id; + Dst.Items := Tab.Tabs; + with TileTab[Tab.TabIndex] do + begin + StartTile.Value := tbr.Current + 1; + TileCount.Value := tbr.TileCount - tbr.Current; + end; + ShowModal; + if Result then + begin + i := Src.Items.IndexOf (Src.Text); + j := Src.Items.IndexOf (Dst.Text); + if (i >= 0) and (j >= 0) { and (TileCount.Value > 0) } then // 2.51 bug fix + begin + MainForm.ProgressPanel.Visible := TRUE; + + ovr := Overwrite.Enabled and Overwrite.Checked; + str := Stretch.Enabled and Stretch.Checked; + scaler := UseScaler.Enabled and UseScaler.Checked; + bnds := CopyBounds.Enabled and CopyBounds.Checked; + + if (i = j) and (StartTile.Value = DstStartTile.Value) then + ShowMessage ('Nothing to do.') + else + CopyTiles (TileTab[i].tbr, + TileTab[j].tbr, + StartTile.Value - 1, + TileCount.Value, + DstStartTile.Value - 1, + ovr, str, scaler, bnds, + i = j, + ProgressBar); + + // mainform.caption := debugstr; + + MainForm.ProgressPanel.Visible := FALSE; + + Tab.TabIndex := j; + TabChange (Sender); + StartEdit (TRUE); + Modified := TRUE; + end; + + end; + end; +end; + +procedure TMainForm.InsertNewTile1Click(Sender: TObject); +begin + UpdateBmp (TRUE); + InsertNewTile (TileTab[Tab.TabIndex].tbr, FALSE); + UpdateTileBitmap; + Modified := TRUE; + StartEdit (TRUE); +end; + +procedure TMainForm.PreviousTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if Current > 0 then + begin + Dec (Current); + StartEdit (FALSE); + end; + DrawCursor; +end; + +procedure TMainForm.NextTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if Current < TileCount - 1 then + begin + Inc (Current); + StartEdit (FALSE); + end + else + if Mode = mTile then + NewTile1Click (Sender); + DrawCursor; +end; + +procedure TMainForm.FirstTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + Current := 0; + StartEdit (FALSE); +end; + +procedure TMainForm.LastTile1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + Current := TileCount - 1; + StartEdit (FALSE); +end; + +procedure TMainForm.StretchPaste1Click(Sender: TObject); + var + i, j, x, y: Integer; + X1, Y1, X2, Y2: Integer; +begin + if Mode = mTile then + begin + if Clipboard.HasFormat(CF_BITMAP) then + begin + X1 := BORDER_W; + Y1 := BORDER_H; + X2 := X1 + W; + Y2 := Y1 + H; + + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + X1 := TileSelX1; + Y1 := TileSelY1; + X2 := TileSelX2; + Y2 := TileSelY2; + end; + + SaveUndo ('Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + SetStretchBltMode(Bmp.Canvas.Handle, HALFTONE); + with ClipBmp do + Bmp.Canvas.CopyRect (Rect (X1, Y1, X2, Y2), + ClipBmp.Canvas, MakeRect (0, 0, ClipBmp.Width, ClipBmp.Height)); + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; + end; + end; + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + y := (j - Top) mod ClipH; + if ClipH > 2 then + y := 1 + ((j - Top) mod (ClipH - 2)); + x := (i - Left) mod ClipW; + if ClipW > 2 then + x := 1 + ((i - Left) mod (ClipW - 2)); + if Top < Bottom then + begin + if j = Top then y := 0; + if j = Bottom then y := ClipH - 1; + end; + if Left < Right then + begin + if i = Left then x := 0; + if i = Right then x := ClipW - 1; + end; + lmp^.Map[j, i] := clip^.Map[y, x]; + end; + Selection := FALSE; + Modified := TRUE; + UpdateMapRegion(Area); + end; +end; + +procedure TMainForm.ToggleMultiple1Click(Sender: TObject); + var + F, L: Integer; +begin + F := LastFromToFirst; + L := LastFromToLast; + LastFromToFirst := FromToFirst; + LastFromToLast := FromToLast; + + if FromToFirst = FromToLast then + begin + if F <> L then + begin + FromToFirst := F; + FromToLast := L; + end + else + begin + FromToFirst := 0; + FromToLast := MAX_FROM_TO - 1; + end; + end + else + begin + if F = L then + begin + FromToFirst := F; + FromToLast := L; + end + else + begin + FromToFirst := F + (L - F) div 2; + FromToLast := FromToFirst; + end; + end; + FromTo.Repaint; +end; + + +procedure TMainForm.SelectBackMidFront(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + + procedure SetBevel (var p: TPanel; Down: Boolean); + begin + if Down then + begin + p.BevelInner := bvLowered; + p.BevelOuter := bvLowered; + end + else + begin + p.BevelInner := bvRaised; + p.BevelOuter := bvRaised; + end; + end; + + var + LastBMF: Integer; +begin + with TileTab[Tab.TabIndex].tbr do + begin + LastBMF := BackMidFront; + if (Sender = pBack) or (Sender = bmpBack) then + BackMidFront := -1 + else if (Sender = pFront) or (Sender = bmpFront) then + BackMidFront := 1 + else + BackMidFront := 0; + + if Button = mbLeft then + SelectCurrentTile (Current) + else + if BackMidFront = LastBMF then + SelectCurrentTile (-1); + end; + ShowSelectedTile; +end; + +procedure TMainForm.ShowSelectedTile; + + procedure SetBevel (var p: TPanel; Down: Boolean); + begin + if Down then + begin + p.BevelInner := bvLowered; + p.BevelOuter := bvLowered; + end + else + begin + p.BevelInner := bvRaised; + p.BevelOuter := bvRaised; + end; + end; + +begin + with TileTab[Tab.TabIndex].tbr do + begin + SetBevel (pBack, BackMidFront = -1); + SetBevel (pMid, BackMidFront = 0); + SetBevel (pFront, BackMidFront = 1); + end; + DrawCurrentTile; +end; + +procedure TMainForm.DrawTile (TabIndex, N: Integer; + var bmp: TImage; + var Mir: Boolean; + var Ups: Boolean; + var Rot: Boolean; + var FullBmp: TImage); + var + Tile: Integer; + RR: TRect; + m, u, r: Boolean; + MirW, UpsH: Integer; + i, j: Integer; + TmpBmp1, TmpBmp2: TBitmap; + +begin + with TileTab[TabIndex].tbr do + begin + + if n = -1 then + begin + Mir := FALSE; + Ups := FALSE; + Rot := FALSE; + FillBitmap (bmp, TRANS_COLOR); + end + else + begin + m := n and MIRROR_MASK = MIRROR_MASK; + u := n and UPS_MASK = UPS_MASK; + r := n and ROTATE_MASK = ROTATE_MASK; + Mir := m; + Ups := u; + Rot := r; + MirW := Byte (m); + UpsH := Byte (u); + Tile := n and TILE_MASK; + RR := Rect (MirW * (W - 1), + UpsH * (H - 1), + W - MirW * (W + 1), + H - UpsH * (H + 1)); + bmp.Canvas.CopyRect (RR, TileBitmap.Canvas, + MakeRect (tile * W, 0, W, H)); + + if r then + begin + TmpBmp1 := TBitmap.Create; + SetStretchBltMode(TmpBmp1.Canvas.Handle, HALFTONE); + with TmpBmp1 do + begin + PixelFormat := pf24bit; + Width := W; + Height := H; + Transparent := TRUE; + TransparentColor := TRANS_COLOR; + for j := 0 to Height - 1 do + for i := 0 to Width - 1 do + Canvas.Pixels[i, j] := Bmp.Canvas.Pixels[i, j]; + end; + TmpBmp2 := TBitmap.Create; + SetStretchBltMode(TmpBmp2.Canvas.Handle, HALFTONE); + with TmpBmp2 do + begin + PixelFormat := pf24bit; + Width := H; + Height := W; + Transparent := TRUE; + TransparentColor := TRANS_COLOR; + for j := 0 to Height - 1 do + for i := 0 to Width - 1 do + Canvas.Pixels[i, j] := TRANS_COLOR; + Canvas.StretchDraw (Rect (0, 0, H, W), TmpBmp1); + end; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + bmp.Canvas.Pixels[i, j] := TmpBmp2.Canvas.Pixels[j, W - 1 - i]; + TmpBmp1.Free; + TmpBmp2.Free; + end; + + FullBMP.Canvas.Draw (0, 0, bmp.Picture.Graphic); + end; + end; +end; + + +procedure TMainForm.DrawCurrentTile; + var + m, u, r: Boolean; + s: string; + tx, ty, tw, th: Integer; + ti: Integer; + ov: Integer; +begin + FillBitmap (bmpPreview, BackGround.Brush.Color); + + ti := Tab.TabIndex; + with TileTab[ti].tbr do + begin + DrawTile (ti, mcr.Back, bmpBack, m, u, r, bmpPreview); + bMir.Down := m; + bUps.Down := u; + bRot.Down := r; + DrawTile (ti, mcr.Mid, bmpMid, m, u, r, bmpPreview); + mMir.Down := m; + mUps.Down := u; + mRot.Down := r; + DrawTile (ti, mcr.Front, bmpFront, m, u, r, bmpPreview); + fMir.Down := m; + fUps.Down := u; + fRot.Down := r; + + ov := TileTab[Tab.TabIndex].tbr.Overlap; + if (ShowBounds1.Checked) and (mcr.Bounds <> 0) then + DrawBounds (bmpPreview.Canvas, 0, ov, W, H, 1, mcr.Bounds, clWhite); + + if (ShowMapCodes1.Checked) and (mcr.MapCode <> 0) then + begin + FillBitmap (bmp1, TRANS_COLOR); + with bmp1.Picture.Bitmap.Canvas do + begin + s := Hex2 (mcr.MapCode); + tw := TextWidth (s); + th := TextHeight (s); + tx := W div 2 - tw div 2; + ty := H div 2 - th div 2; + Font.Color := clBlack; + TextOut (tx, ty, s); + bmpPreview.Picture.Bitmap.Canvas.Draw (0, 0, bmp1.Picture.Bitmap); + Font.Color := clWhite; + TextOut (tx, ty, s); + bmpPreview.Picture.Bitmap.Canvas.Draw (-1, -1, bmp1.Picture.Bitmap); + end; + end; + + end; + + BoundBox.Repaint; + if Mode = mMap then + with MapCodeButton do + Caption := Hex2 (TileTab[Tab.TabIndex].tbr.mcr.MapCode); +end; + +procedure TMainForm.SelectCurrentTile (n: Integer); + var + i, j, k, Bnds: Integer; +begin + with TileTab[Tab.TabIndex].tbr do + begin + Bnds := 0; + if n < TileCount then + begin + k := n; + Bnds := GetBound (TileTab[Tab.TabIndex].tbr, -1); + end + else + k := -1; + if k = -1 then + case BackMidFront of + -1: if HasCurrentBounds (mcr.Back) then + MainForm.Bounds := 0; + 0: if HasCurrentBounds (mcr.Mid) then + MainForm.Bounds := 0; + 1: if HasCurrentBounds (mcr.Front) then + MainForm.Bounds := 0; + end + else + if Bnds <> 0 then + if Mode = mTile then + mcr.Bounds := Bnds + else + MainForm.Bounds := Bnds; + case BackMidFront of + -1: mcr.Back := k; + 0: mcr.Mid := k; + 1: mcr.Front := k; + end; + mcr.MapCode := 0; + + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + with lmp^.Map[j, i] do + case BackMidFront of + -1: Back := k; + 0: Mid := k; + 1: Front := k; + end; + end; + Selection := FALSE; + UpdateMapRegion(Area); + end; + + end; +end; + + +procedure TMainForm.MirTileMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + with Sender as TSpeedButton do + Down := TRUE; + +end; + +function TMainForm.HasCurrentBounds (Tile: SmallInt): Boolean; + var + i: Integer; + b: Integer; + m, u: Boolean; +begin + Result := FALSE; + if Tile <> -1 then + begin + i := Tile and TILE_MASK; + m := Tile and MIRROR_MASK <> 0; + u := Tile and UPS_MASK <> 0; + b := GetBound (TileTab[Tab.TabIndex].tbr, i); + if m then + HFlipBounds (b); + if u then + VFlipBounds (b); + Result := b = Bounds; + end; +end; + +procedure TMainForm.fUpsClick(Sender: TObject); + + procedure Flip (m, u, r: Boolean; var Tile: SmallInt); + begin + if Tile <> -1 then + begin + if m then + begin + if HasCurrentBounds (Tile) then + HFlipBounds (Bounds); + Tile := SmallInt (Word (Tile) xor MIRROR_MASK); + end; + if u then + begin + if HasCurrentBounds (Tile) then + VFlipBounds (Bounds); + Tile := SmallInt (Word (Tile) xor UPS_MASK); + end; + if r then + begin + if HasCurrentBounds (Tile) then + RotateBounds (Bounds, -90); + Tile := SmallInt (Word (Tile) xor ROTATE_MASK); + end; + end; + end; + +begin + with TileTab[Tab.TabIndex].tbr.mcr do + begin + Flip (Sender = bMir, Sender = bUps, Sender = bRot, Back); + Flip (Sender = mMir, Sender = mUps, Sender = mRot, Mid); + Flip (Sender = fMir, Sender = fUps, Sender = fRot, Front); + end; + DrawCurrentTile; +end; + +procedure FlipBit (var i: SmallInt; Mask: Integer); +begin + if i <> -1 then + i := i xor SmallInt (Mask); +end; + +procedure TMainForm.MirSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + var + mcr: MapCellRec; + i: Integer; +begin + mcr := mcr1; + mcr1 := mcr2; + mcr2 := mcr; + + i := mcr1.Bounds; + HFlipBounds (i); + mcr1.Bounds := i; + with mcr1 do + begin + FlipBit (Back, MIRROR_MASK); + FlipBit (Mid, MIRROR_MASK); + FlipBit (Front, MIRROR_MASK); + end; + + if MirBoth then + begin + i := mcr2.Bounds; + HFlipBounds (i); + mcr2.Bounds := i; + with mcr2 do + begin + FlipBit (Back, MIRROR_MASK); + FlipBit (Mid, MIRROR_MASK); + FlipBit (Front, MIRROR_MASK); + end; + end; +end; + +procedure TMainForm.UpsSwap (var mcr1: MapCellRec; var mcr2: MapCellRec; MirBoth: Boolean); + var + mcr: MapCellRec; + i: Integer; +begin + mcr := mcr1; + mcr1 := mcr2; + mcr2 := mcr; + + i := mcr1.Bounds; + VFlipBounds (i); + mcr1.Bounds := i; + with mcr1 do + begin + FlipBit (Back, UPS_MASK); + FlipBit (Mid, UPS_MASK); + FlipBit (Front, UPS_MASK); + end; + + if MirBoth then + begin + i := mcr2.Bounds; + VFlipBounds (i); + mcr2.Bounds := i; + with mcr2 do + begin + FlipBit (Back, UPS_MASK); + FlipBit (Mid, UPS_MASK); + FlipBit (Front, UPS_MASK); + end; + end; +end; + +procedure TMainForm.Horizontal2Click(Sender: TObject); + var + i, j, k, l: Integer; +begin + if Mode <> mMap then + Exit; + if Selection then + begin + k := (Area.Right - Area.Left + 2) div 2; + for j := Area.Top to Area.Bottom do + for i := Area.Left to (Area.Left + k - 1) do + begin + l := Area.Right - (i - Area.Left); + MirSwap (lmp^.Map[j, i], lmp^.Map[j, l], i <> l); + end; + Modified := TRUE; + // Selection := FALSE; + UpdateMapRegion(Area); + end + else + with TileTab[Tab.TabIndex].tbr do + case BackMidFront of + -1: fUpsClick (bMir); + 0: fUpsClick (mMir); + 1: fUpsClick (fMir); + end; +end; + +procedure TMainForm.Vertical2Click(Sender: TObject); + var + i, j, k, l: Integer; +begin + if Mode <> mMap then + Exit; + if Selection then + begin + k := (Area.Bottom - Area.Top + 2) div 2; + for j := Area.Top to Area.Top + k - 1 do + for i := Area.Left to Area.Right do + begin + l := Area.Bottom - (j - Area.Top); + UpsSwap (lmp^.Map[j, i], lmp^.Map[l, i], j <> l); + end; + Modified := TRUE; + // Selection := FALSE; + UpdateMapRegion(Area); + end + else + with TileTab[Tab.TabIndex].tbr do + case BackMidFront of + -1: fUpsClick (bUps); + 0: fUpsClick (mUps); + 1: fUpsClick (fUps); + end; +end; + +procedure TMainForm.SelectCurrentTile1Click(Sender: TObject); +begin + SelectCurrentTile (TileTab[Tab.TabIndex].tbr.Current); + DrawCurrentTile; +end; + +procedure TMainForm.Next1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Inc (BackMidFront, 2); + BackMidFront := BackMidFront mod 3; + Dec (BackMidFront); + end; + ShowSelectedTile; +end; + +procedure TMainForm.Previous1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + BackMidFront := (BackMidFront + 3) mod 3; + Dec (BackMidFront); + end; + ShowSelectedTile; +end; + +procedure TMainForm.ToggleTileMapEditor1Click(Sender: TObject); +begin + if Mode = mTile then + SetEditorMode (mMap) + else + if Mode = mMap then + SetEditorMode (mTile); +end; + +procedure TMainForm.MapCodeButtonClick(Sender: TObject); + var + i, j: Integer; +begin + MapCode.Value := TileTab[Tab.TabIndex].tbr.mcr.MapCode; + MapCode.ShowModal; + TileTab[Tab.TabIndex].tbr.mcr.MapCode := MapCode.Value; + // if MapCode.Value < $A then + MapCodeButton.Caption := Hex2 (MapCode.Value); + ShowSelectedTile; + + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + lmp^.Map[j, i].MapCode := MapCode.Value; + { RD: Clear selection; redraw area } + Selection := FALSE; + UpdateMapRegion(Area); + end; + + // else + // MapCodeButton.Caption := '0x' + Hex2 (MapCode.Value); +end; + +procedure TMainForm.Map1Click(Sender: TObject); +begin + with NewForm do + begin + NewMode := nmNewMap; + CreateNew := TRUE; + DefaultName := NewMapName; + CanChangeSize := TRUE; + DefaultOverlap := TileTab[Tab.TabIndex].tbr.Overlap; + ShowModal; + + if Result then + if MapTab.Tabs.IndexOf (Identifier.Text) <> -1 then // bug fix + Msg ('Name ' + Identifier.Text + ' already in use.') + else + begin + NewMap (TileTab[Tab.TabIndex].tbr, Identifier.Text, NH.Value, NV.Value); + + MapTab.TabIndex := MapTab.Tabs.Add (Identifier.Text); + MapTabChange (Sender); + + with TileTab[Tab.TabIndex].tbr do + Maps.aMaps[Maps.CurMap].SkipExport := Skip.Checked; // 2.2 + + if Mode = mTile then + SetEditorMode (mMap); + end; + end; +end; + +procedure TMainForm.ShowUsedColors1Click(Sender: TObject); + var + bmp: TBitmap; + x, y: Integer; + i, j, k: Integer; + Found: Boolean; + ai: array of Integer; + ColorMask: Integer; +begin + if N61.Checked then + ColorMask := $FCFCFC + else + if N71.Checked then + ColorMask := $FEFEFE + else + ColorMask := $FFFFFF; + with ShowUsedColors1 do + begin + Checked := not Checked; + if Checked then + begin + with ProgressBar do + begin + Min := 0; + with TileTab[Tab.TabIndex].tbr.TileBitmap do + Max := Width * Height; + Position := Min; + end; + ProgressPanel.Visible := TRUE; + bmp := TBitmap.Create; + SetStretchBltMode(bmp.Canvas.Handle, HALFTONE); + with bmp do + begin + PixelFormat := pf24bit; + Width := 1; + Height := 1; + Canvas.Pixels[0, 0] := TRANS_COLOR; + k := 1; + SetLength (ai, k); + ai[0] := TRANS_COLOR; + with TileTab[Tab.TabIndex].tbr.TileBitmap do + for y := 0 to Height - 1 do + begin + for x := 0 to Width - 1 do + begin + i := Canvas.Pixels[x, y]; + if i <> TRANS_COLOR then + i := (i and ColorMask); + Found := FALSE; + for j := 0 to k - 1 do + if not Found then + // if bmp.Canvas.Pixels[0, j] = i then + if ai[j] = i then + Found := TRUE; + if not Found then + begin + Inc (k); + SetLength (ai, k); + ai[k - 1] := i; + bmp.Height := k; + bmp.Canvas.Pixels[0, k - 1] := i; + end; + if x mod 16 = 0 then + ProgressBar.Position := y * Width + x; + end; + end; + Canvas.Pixels[0, 0] := BackGround.Brush.Color; + SetLength (ai, 0); + end; + ProgressPanel.Visible := FALSE; + UsedColorsImage.Picture.Bitmap := bmp; + UsedColors.Hint := IntToStr (bmp.Height) + ' colors used'; + UsedColors.ShowHint := TRUE; + bmp.Free; + UsedColorsImage.Stretch := TRUE; + UsedColors.Visible := TRUE; + MainForm.Resize; + end + else + HideUsedColors; + end; + UsedColorSelect := FALSE; +end; + +procedure TMainForm.HideUsedColors; +begin + if UsedColors.Visible then + begin + UsedColors.Visible := FALSE; + ShowUsedColors1.Checked := FALSE; + ShowCurrentPalette1.Checked := FALSE; + MainForm.Resize; + end; + UsedColorSelect := FALSE; +end; + +procedure TMainForm.UsedColorsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + UsedColorSelect := TRUE; + UsedColorsImageMouseMove (Sender, Shift, X, Y); +end; + +procedure TMainForm.UsedColorsImageMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + var + c, j: Integer; +begin + with UsedColorsImage.Picture do + begin + j := y * Bitmap.Height div UsedColorsImage.Height; + c := Bitmap.Canvas.Pixels[0, j]; + ShowRGB (c); // 2.51 + end; + if UsedColorSelect then + SetColor (c, FALSE, FALSE) +end; + +procedure TMainForm.UsedColorsImageMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Color.Brush.Color = BackGround.Brush.Color then + SetBackGroundColor (Color.Brush.Color, TRUE); + UsedColorSelect := FALSE; +end; + +procedure TMainForm.MapProperties1Click(Sender: TObject); +begin + if MapTab.TabIndex > -1 then + with NewForm do + begin + NewMode := nmMapProperties; + CreateNew := FALSE; + DefaultName := MapTab.Tabs.Strings[MapTab.TabIndex]; + + with TileTab[Tab.TabIndex].tbr do + Skip.Checked := Maps.aMaps[Maps.CurMap].SkipExport; // 2.2 + + with lmp^ do + begin + NH.Value := Length (Map[0]); + NV.Value := Length (Map); + end; + CanChangeSize := TRUE; + DefaultOverlap := TileTab[Tab.TabIndex].tbr.Overlap; + + // todo: something causes a breakpoint in ntdll.dll here + ShowModal; + + if Result then + begin + if Identifier.Text <> DefaultName then + if MapTab.Tabs.IndexOf (Identifier.Text) <> -1 then // bug fix + begin + Msg ('Name ' + Identifier.Text + ' already in use.'); + Identifier.Text := DefaultName; + end; + + with lmp^ do + begin + Id := Identifier.Text; + SetMapSize (Map, NH.Value, NV.Value); + end; + MapTab.Tabs.Strings[MapTab.TabIndex] := Identifier.Text; + MapTabChange (Sender); + + with TileTab[Tab.TabIndex].tbr do + Maps.aMaps[Maps.CurMap].SkipExport := Skip.Checked; // 2.2 + + if Mode = mTile then + SetEditorMode (mMap); + { RD: Redraw whole map (with altered dimensions) } + UpdateMap; + end; + end; + +end; + +procedure TMainForm.GetMCRTile (var MCR: MapCellRec; var Tile: Integer; + var Mir: Boolean; var Ups: Boolean); +begin + with MCR do + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: Tile := Back; + 0: Tile := Mid; + 1: Tile := Front; + end; + if Tile <> -1 then + begin + Mir := (Tile and MIRROR_MASK) <> 0; + Ups := (Tile and UPS_MASK) <> 0; + Tile := Tile and TILE_MASK; + end + else + begin + Mir := FALSE; + Ups := FALSE; + end; +end; + +procedure TMainForm.SetMCRTile (var MCR: MapCellRec; Tile: Integer; + Mir, Ups: Boolean); +begin + if Tile <> -1 then + begin + if Mir then Tile := Tile or MIRROR_MASK; + if Ups then Tile := Tile or UPS_MASK; + end; + with MCR do + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: Back := SmallInt (Tile); // 2.54: bugfix (Range check error) + 0: Mid := SmallInt (Tile); + 1: Front := SmallInt (Tile); + end; + Modified := TRUE; +end; + +procedure TMainForm.AddMCR (var MCR: MapCellRec; n: Integer); + var + Tile: Integer; + m, u: Boolean; + Max: Integer; +begin + GetMCRTile (MCR, Tile, m, u); + if Tile < 0 then + begin + Tile := TileTab[Tab.TabIndex].tbr.Current; + m := FALSE; + u := FALSE; + end; + Inc (Tile, n); + Max := TileTab[Tab.TabIndex].tbr.TileCount; /// - 1; + if Max < 1 then + Max := 1; + Tile := Tile mod Max; + SetMCRTile (MCR, Tile, m, u); +end; + +procedure TMainForm.DrawMap (Area: TRect; ExportingImage: Boolean; Clp, Sq: Boolean); + var + i, j, tx, ty, tw, th, tmpw, tmph, min_i, min_j, ii, jj: Integer; + mcr: MapCellRec; + m, u, r: Boolean; + DrawAll: Boolean; + s: string; + X1, Y1, X2, Y2, EY1, EY2: Integer; + bmpBitmap: TBitmap; + ptr: LayerMapPtr; + ov: Integer; + Selected, CellSelected: Boolean; + CL1, CL2: Integer; +begin + + min_i := 0; + min_j := 0; + + Selected := false; + if Selection then Selected := true; + if DrawingInMap and (MapDrawingTool in [mdtFilledRect, mdtRect, mdtZOrder]) then + Selected := true; + if Sq or Clp then + Selected := false; + + SkipDraw := TRUE; + DrawAll := (Area.Left = 0) and (Area.Top = 0) and + (Area.Right = -1) and (Area.Bottom = -1); + + ov := TileTab[Tab.TabIndex].tbr.Overlap; + + if Sq then + begin + ptr := seq; + bmpBitmap := SeqBitmap.Picture.Bitmap; + DrawAll := FALSE; + end + else + begin + if Clp then + begin + ptr := clip; + bmpBitmap := ClipBitmap.Picture.Bitmap; + end + else + begin + ptr := lmp; + if ExportingImage then // 2.5 + bmpBitmap := bmpMapImage + else + bmpBitmap := bmpMap; + end; + end; + + if ptr <> nil then + with ptr^ do + if Length (Map) > 0 then + begin + if not Sq then + begin + CurMapH := Length (Map); + CurMapW := Length (Map[0]); + if Clp or ExportingImage then // 2.51 bug fix + begin + bmpBitmap.Width := CurMapW * W; + bmpBitmap.Height := CurMapH * (H - ov); + end + else + begin + bmpBitmap.Width := (VisibleMapRegion.Right - VisibleMapRegion.Left + 1) * W; + bmpBitmap.Height := (VisibleMapRegion.Bottom - VisibleMapRegion.Top + 1) * (H - ov); + end; + end; + + // ResizeBitmap (bmpMap); + if DrawAll then + begin + X1 := 0; + Y1 := 0; + X2 := CurMapW - 1; + Y2 := CurMapH - 1; + end + else + begin + X1 := Area.Left; + Y1 := Area.Top; + X2 := min(Area.Right, CurMapW - 1); + Y2 := min(Area.Bottom, CurMapH - 1); + end; + + if not (Clp or Sq or ExportingImage) then // 2.51 bug fix + begin + X1 := max(X1, VisibleMapRegion.Left); + Y1 := max(Y1, VisibleMapRegion.Top); + X2 := min(X2, VisibleMapRegion.Right); + Y2 := min(Y2, VisibleMapRegion.Bottom); + min_i := VisibleMapRegion.Left; + min_j := VisibleMapRegion.Top; + end; + + EY1 := Y1; + EY2 := Y2; + + { + // 2.5 - removed + + if (not (Sq or Clp)) and (ov > 0) then + begin + if EY1 > 0 then Dec (EY1); + if EY2 < SizeOf ??? (map) then Inc (EY2); + end; + } + + ///* + + begin + for j := EY1 to EY2 do + for i := X1 to X2 do + // if DrawAll or Inside (i, j, Area) then + begin + mcr := map[j, i]; + CellSelected := Selected and Inside(i, j, Self.Area); + FillBitmap (bmp1, TRANS_COLOR); + if Sq then + FillBitmap (bmp2, BackGround.Brush.Color) + else + FillBitmap (bmp2, TRANS_COLOR); + + if ShowGrid1.Checked then + with bmp2.Picture.Bitmap.Canvas do + begin + CL1 := clBlack; + CL2 := clWhite; + + if MapGridX > 0 then // 2.54 + begin + if i mod MapGridX = 0 then CL1 := clRed; + if (i + 1) mod MapGridX = 0 then CL2 := clRed; + end; + if MapGridY > 0 then + begin + if j mod MapGridY = 0 then CL1 := clRed; + if (j + 1) mod MapGridY = 0 then CL2 := clRed; + end; + + if MapGridX > 0 then + for jj := ov to H - 1 do + begin + if i mod MapGridX = 0 then Pixels[0, jj] := clWhite; + if (i + 1) mod MapGridX = 0 then Pixels[W - 1, jj] := clBlack; + end; + + if MapGridY > 0 then + for ii := 0 to W - 1 do + begin + if j mod MapGridY = 0 then Pixels[ii, ov] := clWhite; + if (j + 1) mod MapGridY = 0 then Pixels[ii, H - 1] := clBlack; + end; + + Pixels[0, 0 + ov] := CL1; + Pixels[W - 1, H - 1] := CL2; + end; + + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then // 2.55 + begin + if CellSelected then + begin + if MapDrawingTool in [mdtFilledRect, mdtZOrder] then + begin + mcr := TileTab[Tab.TabIndex].tbr.mcr; + if MapDrawingTool in [mdtZOrder] then + AddMCR (mcr, i - X1 + (j - Y1) * (X2 - X1 + 1)); + end; + end; + if mcr.Back <> -1 then + if ShowBackLayer.Checked then + DrawTile (Tab.TabIndex, mcr.Back, bmp1, m, u, r, bmp2); + if mcr.Mid <> -1 then + if ShowMidLayer.Checked then + DrawTile (Tab.TabIndex, mcr.Mid, bmp1, m, u, r, bmp2); + if mcr.Front <> -1 then + if ShowFrontLayer.Checked then + DrawTile (Tab.TabIndex, mcr.Front, bmp1, m, u, r, bmp2); + end; + + if sq then + bmpBitmap.Canvas.CopyRect + (MakeRect (0, 0, W, H), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0, W, H)) + else + begin + + // if mcr.Bounds <> $FF then // 2.55 + // if mcr.Bounds <> 0 then + // if mcr.Bounds and $40 = 0 then // allow bounds with sequences + begin + if CellSelected then + if MapDrawingTool in [mdtRect] then + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, SelBmp.Picture.Bitmap); + + if ShowBounds1.Checked then + DrawBounds (bmp2.Canvas, 0, ov, W, H, 1, mcr.Bounds, clWhite); + end; + + if (ShowMapCodes1.Checked and (mcr.MapCode <> 0)) or + // (mcr.Bounds = $FF) then // 2.55 + // (mcr.Bounds < 0) then + (mcr.Bounds and $40 <> 0) then + begin + FillBitmap (bmp1, TRANS_COLOR); + with bmp1.Picture.Bitmap.Canvas do + begin + s := Hex2 (mcr.MapCode); + tw := TextWidth (s); + th := TextHeight (s); + tx := W div 2 - tw div 2; + ty := ov + (H - ov) div 2 - th div 2; + Font.Color := clBlack; + TextOut (tx, ty, s); + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, bmp1.Picture.Bitmap); + Font.Color := clWhite; + // if mcr.Bounds = $FF then + // if mcr.Bounds < 0 then // 2.55 + if mcr.Bounds and $40 <> 0 then + Font.Color := clRed; + TextOut (tx, ty, s); + bmp2.Picture.Bitmap.Canvas.Draw (-1, -1, bmp1.Picture.Bitmap); + end; + end; + + if ExportingImage then + // if (not ShowMapCodes1.Checked) and (mcr.Bounds = $FF) then // 2.55 + if (not ShowMapCodes1.Checked) and (mcr.Bounds and $40 <> 0) then + begin + SeqTab.TabIndex := mcr.MapCode; + SkipDraw := FALSE; + SeqTabChange (nil); + SkipDraw := TRUE; + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, SeqBitmap.Picture.Bitmap); + end; + + bmp1.Picture.Bitmap.Canvas.CopyRect + (MakeRect (0, 0, W, H), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0, W, H)); + + FillBitmap (bmp2, BackGround.Brush.Color); + bmp2.Picture.Bitmap.Canvas.Draw (0, 0, bmp1.Picture.Bitmap); + + if (j >= Y1) and (j <= Y2) then + bmpBitmap.Canvas.CopyRect + (MakeRect ((i - min_i) * W, (j - min_j) * (H - ov), W, H - ov), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0 + ov, W, H)); + + if (ov > 0) then + if (j > Y1) or (not CellSelected) then + with bmp1.Picture.Graphic do + begin + tmpw := Width; + tmph := Height; + Width := W; + Height := ov; + bmpBitmap.Canvas.Draw + ((i - min_i) * W, (j - min_j) * (H - ov) - ov, + bmp1.Picture.Graphic); + Width := tmpw; + Height := tmph; + end; + + end; + + end; + end; + end; + + SkipDraw := FALSE; +end; + +procedure TMainForm.ZoomMap; + var + z1, z2: Integer; +begin +// MapDisplay.Width := bmpMap.Width * ZOOM_FACTOR div Zoom; +// MapDisplay.Height := bmpMap.Height * ZOOM_FACTOR div Zoom; + + ZoomIn1.Enabled := (Zoom > 1); + ZoomOut1.Enabled := (Zoom < MAX_ZOOM); + z1 := ZOOM_FACTOR; + z2 := Zoom; + if (z1 mod 3 = 0) and (z2 mod 3 = 0) then + begin + z1 := z1 div 3; + z2 := z2 div 3; + end; + if (z1 mod 2 = 0) and (z2 mod 2 = 0) then + begin + z1 := z1 div 2; + z2 := z2 div 2; + end; + StatusBar.Panels[4].Text := Format ('%d:%d', [z1, z2]); +end; + +procedure TMainForm.MapTabChange(Sender: TObject); + var + tw, th: integer; +begin + // SeqTimer.Enabled := FALSE; + if MapTab.TabIndex >= 0 then + begin + MapDisplay.Visible := TRUE; + + // 2.42 + with TileTab[Tab.TabIndex].tbr.Maps.aMaps[MapTab.TabIndex] do + begin + CurMapH := Length (Map); + CurMapW := Length (Map[0]); + end; + with TileTab[Tab.TabIndex].tbr do + begin + tw := W * ZOOM_FACTOR div Zoom; + th := (H - Overlap) * ZOOM_FACTOR div Zoom; + end; + MapDisplay.Width := tw * CurMapW; + MapDisplay.Height := th * CurMapH; + + ZoomIn1.Enabled := (Zoom > 1); + ZoomOut1.Enabled := (Zoom < MAX_ZOOM); + + UpdateMap; + end + else + MapDisplay.Visible := FALSE; + + ShowStatusInfo; // 2.53 + + Selection := FALSE; + Area := Rect (0, 0, 0, 0); +end; + +procedure TMainForm.ShowGrid1Click(Sender: TObject); +begin + ShowGrid1.Checked := not ShowGrid1.Checked; + if ShowGrid1.Checked then + ShowGrid1.Tag := ShowGrid1.Tag + 1; + UpdateMap; +end; + +procedure TMainForm.bmpMapMouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + MapX, MapY: Integer; + ov: Integer; +begin + ov := TileTab[Tab.TabIndex].tbr.Overlap; + ShiftState := Shift; + MapX := (X * Zoom div ZOOM_FACTOR) div W; + MapY := (Y * Zoom div ZOOM_FACTOR) div (H - ov); + if MapDrawingTool in [mdtRect] then + if Selection then + begin + Selection := FALSE; + UpdateMapRegion(Area); + end; + + if Button = mbLeft then + begin + // 2.55 - don't erase bounds + if (MapDrawingTool = mdtRect) then + begin + Bounds := 0; + BoundBox.RePaint; + end; + end; + + MapOrigin := Point (MapX, MapY); + Area := MakeRect (MapX, MapY, 0, 0); + LastArea := Area; + if Button = mbLeft then + begin + DrawingInMap := TRUE; + Modified := TRUE; + end; + if Button = mbRight then + ReadingFromMap := TRUE; + bmpMapMouseMove (Sender, Shift, X, Y); + MapPos := Point (-1, -1); +end; + +procedure TMainForm.bmpMapMouseMove(Sender: TObject; Shift: TShiftState; X, + Y: Integer); + var + MapX, MapY: Integer; + Tile: Integer; + m, u: Boolean; + ov: Integer; +begin + ov := TileTab[Tab.TabIndex].tbr.Overlap; + MapX := (X * Zoom div ZOOM_FACTOR) div W; + MapY := (Y * Zoom div ZOOM_FACTOR) div (H - ov); + StatusBar.Panels[1].Text := Format ('(%d, %d)', [MapX, MapY]); + // ExtendArea (Area, MapX, MapY); + if lmp <> nil then + if (MapX >= 0) and (MapX < CurMapW) and + (MapY >= 0) and (MapY < CurMapH) then + with lmp^ do + begin + if DrawingInMap then + begin + if MapDrawingTool = mdtPoint then + begin + if ssShift in ShiftState then + begin + GetMCRTile (TileTab[Tab.TabIndex].tbr.mcr, Tile, m, u); + + SetMCRTile (lmp^.Map[MapY, MapX], Tile, m, u); + end + else + lmp^.Map[MapY, MapX] := TileTab[Tab.TabIndex].tbr.mcr; + { RD: Redraw new tile } + UpdateMapRegion(Area); + Area := MakeRect (MapX, MapY, 0, 0); + end; + + if MapDrawingTool in [mdtFilledRect, mdtRect, mdtZOrder] then + begin + if (MapX <> MapPos.X) or (MapY <> MapPos.Y) then + begin + Area := MakeArea (MapOrigin.X, MapOrigin.Y, MapX, MapY); + if MapPos.X = -1 then LastArea := Area; + MapPos := Point (MapX, MapY); + UpdateMapRegion(Rect(min(Area.Left, LastArea.Left), + min(Area.Top, LastArea.Top), + max(Area.Right, LastArea.Right), + max(Area.Bottom, LastArea.Bottom))); + LastArea := Area; + end; + end; + + end; + + if ReadingFromMap then + begin + TileTab[Tab.TabIndex].tbr.mcr := lmp^.Map[MapY, MapX]; + Bounds := TileTab[Tab.TabIndex].tbr.mcr.Bounds; + ShowSelectedTile; + + + // 2.5 - go to selected tile + Tile := -1; + with TileTab[Tab.TabIndex].tbr.mcr do + begin + if Front <> -1 then + Tile := Front and TILE_MASK + else + if Mid <> -1 then + Tile := Mid and TILE_MASK + else + if Back <> -1 then + Tile := Back and TILE_MASK; + end; + + if Tile <> -1 then + begin + with TileTab[Tab.TabIndex].tbr do + Current := Tile; + StartEdit (FALSE); + end; + + end; + + end; + + ShowStatusInfo; +end; + +function TMainForm.CombineMCR (OldMCR, NewMCR: MapCellRec): MapCellRec; + var + Tile: Integer; + m, u: Boolean; + mcr: MapCellRec; +begin + mcr := OldMCR; + GetMCRTile (NewMCR, Tile, m, u); + SetMCRTile (mcr, Tile, m, u); + CombineMCR := mcr; +end; + +procedure TMainForm.bmpMapMouseUp(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + var + i, j: Integer; + mcr: MapCellRec; +begin + if Button = mbLeft then + begin + DrawingInMap := FALSE; + if MapDrawingTool in [mdtFilledRect, mdtZOrder] then + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + mcr := TileTab[Tab.TabIndex].tbr.mcr; + if MapDrawingTool in [mdtZOrder] then + begin + AddMCR (mcr, i - Area.Left + (j - Area.Top) * + (Area.Right - Area.Left + 1)); + lmp^.Map[j, i] := CombineMCR (lmp^.Map[j, i], mcr); + end + else + lmp^.Map[j, i] := mcr; + end; + if MapDrawingTool in [mdtRect] then + begin + Selection := TRUE; + ClearMCR (TileTab[Tab.TabIndex].tbr.mcr); + Bounds := TileTab[Tab.TabIndex].tbr.mcr.Bounds; + ShowSelectedTile; + end + else + UpdateMapRegion(Area); + end; + if Button = mbRight then + ReadingFromMap := FALSE; +end; + +procedure TMainForm.SetMapDrawingTool(Sender: TObject); +begin + if Selection then + begin + UpdateMapRegion(Area); + Selection := FALSE; + end; + + if Sender = MapPointButton then + begin + MapDrawingTool := mdtPoint; + + + end; + + if Sender = MapRectButton then + begin + MapDrawingTool := mdtFilledRect; + + end; + + if Sender = ZOrderButton then + begin + MapDrawingTool := mdtZOrder; + + end; + + if Sender = BlockButton then + begin + MapDrawingTool := mdtRect; + + end; + + ShowStatusInfo; + Modified := TRUE; +end; + +procedure TMainForm.bmpPreviewMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if Button = mbRight then + begin + ClearMCR (TileTab[Tab.TabIndex].tbr.mcr); + ShowSelectedTile; + end; +end; + +procedure TMainForm.ShowMapCodes1Click(Sender: TObject); +begin + ShowMapCodes1.Checked := not ShowMapCodes1.Checked; + UpdateMap; + ShowSelectedTile; +end; + +procedure TMainForm.ShowBounds1Click(Sender: TObject); +begin + ShowBounds1.Checked := not ShowBounds1.Checked; + UpdateMap; + ShowSelectedTile; +end; + +procedure TMainForm.ClearArea1Click(Sender: TObject); +begin + if Mode = mMap then + SelectCurrentTile (-1); +end; + +procedure TMainForm.ClipTabChange(Sender: TObject); + var + i: Integer; + ov: Integer; +begin + if ClipTab.TabIndex < 0 then + begin + clip := nil; + ClipBitmap.Visible := FALSE; + + Exit; + end; + ov := TileTab[Tab.TabIndex].tbr.Overlap; + clip := SelectClipMap (TileTab[Tab.TabIndex].tbr, ClipTab.TabIndex); + if clip <> nil then + begin + ClipH := Length (clip^.map); + if ClipH > 0 then + begin + ClipW := Length (clip^.map[0]); + + ClipBitmap.Visible := TRUE; + ClipBitmap.Width := ClipW * W; + ClipBitmap.Height := ClipH * (H - ov); + ResizeBitmap (ClipBitmap); + + { RD: draw clipped map } + DrawMap (Rect (0, 0, ClipW - 1, ClipH - 1), FALSE, TRUE, FALSE); + + ClipBitmap.Stretch := TRUE; + i := 1; + repeat + ClipBitmap.Width := ClipW * W div i; + ClipBitmap.Height := ClipH * (H - ov) div i; + Inc (i); + until (i >= 5) or + ((ClipBitmap.Width < ClipScrollBox.ClientWidth) and + (ClipBitmap.Height < ClipScrollBox.ClientHeight)); + + // ClipBitmap.Repaint; + end; + end; +end; + +procedure TMainForm.RandomFill1Click(Sender: TObject); + var + i, j, x, y: Integer; +begin + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + y := Random (ClipH); + x := Random (ClipW); + lmp^.Map[j, i] := clip^.Map[y, x]; + end; + { RD: clear selection } + Selection := FALSE; + UpdateMapRegion(Area); + end; + Modified := TRUE; +end; + +procedure TMainForm.RemoveMap1Click(Sender: TObject); // remove map + var + i: Integer; +begin + if MapTab.TabIndex > -1 then + begin + RemoveCurrentMap (TileTab[Tab.TabIndex].tbr); + with MapTab do + begin + i := TabIndex; + Tabs.Delete (i); + if i <= Tabs.Count - 1 then + TabIndex := i + else + TabIndex := Tabs.Count - 1; + end; + MapTabChange (Sender); + Modified := TRUE; + end; +end; + +procedure TMainForm.RemoveTileSet1Click(Sender: TObject); + var + i: Integer; +begin + if (Length (TileTab[Tab.TabIndex].tbr.Maps.aMaps) = 0) or + (Sender = nil) or + (MessageDlg ('One or more maps will be deleted. Continue?', + mtWarning, [mbYes, mbNo], 0) = mrYes) then + begin + FreeTBR (TileTab[Tab.TabIndex].tbr); + for i := Tab.TabIndex + 1 to Length (TileTab) - 1 do + TileTab[i - 1] := TileTab[i]; + SetLength (TileTab, Length (TileTab) - 1); + i := Tab.TabIndex; + Tab.Tabs.Delete (Tab.TabIndex); + if i <= Tab.Tabs.Count - 1 then + Tab.TabIndex := i + else + Tab.TabIndex := Tab.Tabs.Count - 1; + + if Sender <> nil then + begin + if Tab.Tabs.Count = 0 then + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + TabChange (Sender); + SetEditorMode (mTile); + end; + Modified := TRUE; + end; +end; + +procedure TMainForm.Save1Click(Sender: TObject); + var + F: File; + i, j, k, np, n: Integer; + TmpStr: string; + + procedure SaveInt (i: Integer); + begin + BlockWrite (F, i, SizeOf (i)); + end; + + procedure SaveChar (c: Char); + var + ch: {$IFDEF UNICODE} AnsiChar {$ELSE} Char {$ENDIF}; + begin + ch := {$IFDEF UNICODE} AnsiChar {$ENDIF} (c); + BlockWrite (F, ch, SizeOf (ch)); + end; + + procedure SaveString (s: string); + var + i: Integer; + begin + SaveInt (SizeOf (Integer) + Length (s)); + SaveInt (Length (s)); + for i := 1 to Length (s) do + SaveChar (s[i]); + end; + +begin + if Filename = '' then + SaveAs1Click (Sender) + else + begin +{$IFDEF CREATE_BACKUP_FILES} + if FileExists (Filename) then + begin + try + if FileExists (Filename + BACKUP_EXT) then + DeleteFile (Filename + BACKUP_EXT); + RenameFile (Filename, Filename + BACKUP_EXT); + except + if MessageDlg ('Error while creating backup file ' + + FileName + BACKUP_EXT + '. Continue?', mtError, [mbYes, mbNo], 0) = mrNo then + Exit; + end; + end; +{$ENDIF} + + ProgressPanel.Visible := TRUE; + ProgressBar.Position := 1; + ProgressBar.Min := 0; + ProgressBar.Max := Length (TileTab); + + AssignFile (F, Filename); + try + ReWrite (F, 1); + + + SaveInt (Ord ('T')); // file signature + SaveInt (Ord ('S')); + + SaveInt (Ord (VERSION_NUMBER[1]) - Ord ('0')); // version + SaveInt (Ord (VERSION_NUMBER[3]) - Ord ('0')); + + SaveInt (Ord ('I')); // 2.0 Project Information + with Info do + TmpStr := #0 + Author.Text + #0 + Notes.Text + #0 + Copyright.Text + + #0 + Chr (Byte (Startup.Checked)); + SaveString (TmpStr); + + SaveInt (Ord ('O')); // Output Path + if OutputtoProjectDirectory1.Checked then + SaveString ('') + else + SaveString (OutputPath); + + if Length (FromToSave) > 0 then + begin + SaveInt (Ord ('F')); // FromTo + SaveInt (Length (FromToSave) * SizeOf (FromToSave[0])); + for i := 0 to Length (FromToSave) - 1 do + BlockWrite (F, FromToSave[i], SizeOf (FromToSave[i])); + end; + + SaveInt (Ord ('C')); // 2.0 Config/options + TmpStr := 'S' + Chr (Ord ('0') + Byte (SmoothPalette1.Checked)) + + 'A' + Chr (aaN); + SaveString (TmpStr); + + SaveInt (Ord ('B')); // Background color + SaveInt (SizeOf (Integer)); + SaveInt (Background.Brush.Color); + + if CodeGen.LastDef <> '' then + begin + SaveInt (Ord ('D')); // Definition file + SaveString (CodeGen.LastDef); + end; + + SaveInt (Ord ('N')); // # TBRs + SaveInt (SizeOf (Integer)); + n := Length (TileTab); + SaveInt (n); + + {$IFDEF SAVETOTALTIME} + SaveInt (Ord ('Z')); + SaveInt (3 * SizeOf (Integer)); + DtTm := Now - StartTime; + SaveInt (aiDtTm[0]); + SaveInt (aiDtTm[1]); + SaveInt (Sessions); + {$ENDIF} + + SaveInt (Ord ('H')); // History + SaveString (History); + + SaveInt (Ord ('T')); // TBR data + SaveInt (0); + + for i := 0 to n - 1 do + begin + + TileTab[i].tbr.LastScale := TileTab[i].lastscale; + + + SaveTBR (F, TileTab[i].ID, TileTab[i].tbr); + + ProgressBar.Position := i + 1; + end; + + + // 2.0 + // np := Length (aaiPal); + // 2.33 + np := Length (aiPalSize); + if np > 0 then + begin + SaveInt (Ord ('P')); + + k := 0; // total palette data size + for i := 0 to np - 1 do + Inc (k, aiPalSize[i]); + j := 0; + for i := 0 to np - 1 do + Inc (j, SizeOf (Integer) + Length (PaletteManager.GetID (i))); + + SaveInt ((1 + // version + 1 + // # palettes + np + // PalSize + np + // Preset + k + // palette data + 2) // DefaultPalette, SelectedPalette + * SizeOf (Integer) + + j); // ID's + + SaveInt (1); // version + SaveInt (np); + for i := 0 to np - 1 do + SaveInt (aiPalSize[i]); + for i := 0 to np - 1 do + SaveInt (aiPreset[i]); + + for i := 0 to np - 1 do + for j := 0 to aiPalSize[i] - 1 do + SaveInt (aaiPal[i, j]); + + for i := 0 to np - 1 do + SaveString (PaletteManager.GetID (i)); + + SaveInt (DefaultPalette); + SaveInt (SelectedPalette); + end; + // + + + + SaveInt (Ord ('L')); // 3.0 Project Lists + with Lists do + SaveString (Notes.Text); + + + + + + SaveInt (0); // End + SaveInt (0); + Modified := FALSE; + except + MessageDlg ('Cannot save file ' + FileName, mtError, [mbOk], 0); + end; + CloseFile (F); + ProgressPanel.Visible := FALSE; + + AddFileToRecentProjects (FileName); + end; + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; +end; + +procedure TMainForm.SaveAs1Click(Sender: TObject); +begin + SaveDialog.Filename := Filename; + if SaveDialog.Execute then + begin + Filename := SaveDialog.Filename; + Save1Click (Sender); + end; +end; + +procedure TMainForm.Open1Click(Sender: TObject); + + var + F: File; + i, j, k, np, n: Integer; + PalVer: Integer; + Error, + Unknown: Boolean; + Cmd: Char; + Len: Integer; + Done: Boolean; + tbr: TileBitmapRec; + ID: string; + VersionHi, + VersionLo: Char; + s: string; + TmpStr: string; + ShowInfo: Boolean; + BackColor: Integer; // 3.0 + + function ReadInt: Integer; + var + i: Integer; + begin + BlockRead (F, i, SizeOf (i)); + ReadInt := i; + end; + + function ReadChar: Char; + var + c: {$IFDEF UNICODE} AnsiChar {$ELSE} Char {$ENDIF}; + begin + BlockRead (F, c, SizeOf (c)); + ReadChar := Char (c); + end; + + function ReadString: string; + var + i, L: Integer; + s: string; + begin + s := ''; + L := ReadInt; + for i := 1 to L do + s := s + ReadChar; + ReadString := s; + end; + +begin + VersionHi := '0'; + VersionLo := '0'; + + ShowInfo := FALSE; + + BackColor := -1; + + if ReadParamFile or OpenDialog.Execute then + begin + if Modified then + if not SaveChanges then + Exit; + + if ReadParamFile then + begin + Filename := FileToOpen; + if not FileExists (Filename) then + Filename := Filename + DEFAULT_EXT; + if not FileExists (Filename) then + begin + MessageDlg ('Cannot open file: ' + Filename, mtError, [mbOk], 0); + Exit; + end; + s := FileName; + if Tab.Tabs.Count > 0 then + CloseAll; + FileName := s; + end + else + begin + CloseAll; + Filename := OpenDialog.Filename; + end; + + ProgressPanel.Visible := TRUE; + ProgressBar.Min := 0; + + + Error := FALSE; + Unknown := FALSE; + AssignFile (F, Filename); + try + Reset (F, 1); + try + + VersionHi := VERSION_NUMBER[1]; + VersionLo := VERSION_NUMBER[3]; + + History := ''; + aaN := 0; { no anti-aliasing } + + if (FileSize (F) > 2 * SizeOf (Integer)) and + (ReadInt = Ord ('T')) and (ReadInt = Ord ('S')) then + begin + StartTime := Now; + DtTm := 0.0; + + ProgressBar.Position := 0; + + VersionHi := Char (ReadInt + Ord ('0')); // Version + VersionLo := Char (ReadInt + Ord ('0')); + + n := 0; + Done := FALSE; + repeat + Cmd := Chr (ReadInt); + Len := ReadInt; + + case Cmd of + #0 : Done := TRUE; + 'L': Lists.Notes.Text := ReadString; + 'I': begin + TmpStr := ReadString; + if TmpStr[1] = #0 then + with Info do + begin + Delete (TmpStr, 1, 1); + + i := Pos (#0, TmpStr); + Author.Text := Copy (TmpStr, 1, i); + Delete (TmpStr, 1, i); + i := Pos (#0, TmpStr); + Notes.Text := Copy (TmpStr, 1, i); + Delete (TmpStr, 1, i); + i := Pos (#0, TmpStr); + Copyright.Text := Copy (TmpStr, 1, i); + Delete (TmpStr, 1, i); + Startup.Checked := TmpStr <> #0; + end; + end; + 'N': begin + n := ReadInt; // # TBRs + ProgressBar.Max := n; + end; + 'T': for i := 1 to n do + begin + + if not ReadTBR (F, ID, tbr, Unknown) then + Error := TRUE; + + if Tab.Tabs.IndexOf (ID) > -1 then + ID := NewTCName; + Tab.Tabs.Add (ID); + Tab.TabIndex := Tab.Tabs.IndexOf (ID); + SetLength (TileTab, Length (TileTab) + 1); + TileTab[Tab.TabIndex].tbr := tbr; + TileTab[Tab.TabIndex].id := ID; + TileTab[Tab.TabIndex].lastscrollpos := 0; + TileTab[Tab.TabIndex].lastscale := tbr.LastScale; + if tbr.BackGr = -1 then + TileTab[Tab.TabIndex].BackGrColor := Background.Brush.Color + else + TileTab[Tab.TabIndex].BackGrColor := tbr.BackGr; + + ProgressBar.Position := i; + end; + 'F': for i := 0 to (Len div SizeOf (FromToSave[0])) - 1 do + begin + SetLength (FromToSave, i + 1); + BlockRead (F, FromToSave[i], SizeOf (FromToSave[i])); + end; + 'B': BackColor := ReadInt; + 'D': CodeGen.LastDef := ReadString; + 'C': begin + TmpStr := ReadString; + i := 1; + while i < Length (TmpStr) do + begin + case TmpStr[i] of + 'S': SmoothPalette1.Checked := TmpStr[i + 1] = '1'; + 'A': aaN := Ord (TmpStr[i + 1]); + end; + Inc (i, 2); + end; + end; + 'O': begin + OutputPath := ReadString; + SelectOutputDirectory1.Checked := OutputPath <> ''; + OutputtoProjectDirectory1.Checked := OutputPath = ''; + if OutputPath = '' then + OutputPath := FilePath (FileName); + end; + 'Z': begin + aiDtTm[0] := ReadInt; + aiDtTm[1] := ReadInt; + StartTime := Now - DtTm; + Sessions := ReadInt + 1; + end; + 'H': History := ReadString; + + // 2.0 + 'P': begin + PalVer := ReadInt; + // version 1 + np := ReadInt; + + for i := 0 to Length (aaiPal) - 1 do + SetLength (aaiPal[i], 0); + SetLength (aaiPal, np); + SetLength (aiPalSize, np); + for i := 0 to np - 1 do + begin + k := ReadInt; + aiPalSize[i] := k; + SetLength (aaiPal[i], k); + end; + SetLength (aiPreset, np); + for i := 0 to np - 1 do + aiPreset[i] := ReadInt; + + for i := 0 to np - 1 do + for j := 0 to aiPalSize[i] - 1 do + aaiPal[i, j] := ReadInt; + + for i := 0 to np - 1 do + begin + ReadInt; // skip size + PaletteManager.SetID (i, ReadString); + end; + + DefaultPalette := ReadInt; + SelectedPalette := ReadInt; + + if PalVer = 2 then + ; + end; + // + else + begin + for i := 1 to Len do + ReadChar; + Unknown := TRUE; + if not (Cmd in ['A'..'Z']) then + Error := TRUE; + end; + end; + until Done or Error; + if Done then + ShowInfo := TRUE; + end + else + Error := TRUE; + except + CloseFile (F); + MessageDlg ('File ' + Filename + ' seems to contain errors.', mtError, [mbOk], 0); + ProgressPanel.Visible := FALSE; + { CloseAll; + NewGame1Click (Sender); } + Exit; + end; + + CloseFile (F); + except + Error := TRUE; + end; + + + if Error then + begin + MessageDlg ('Cannot open file: ' + Filename, mtError, [mbOk], 0); + CloseAll; + NewGame1Click (Sender); + end + else + begin + with ProgressBar do + Position := Max; + + if Unknown then + begin + if (VersionHi > VERSION_NUMBER[1]) or + ((VersionHi = VERSION_NUMBER[1]) and + (VersionLo > VERSION_NUMBER[3])) then + MessageDlg ('The file ' + Filename + + ' was saved with a newer version of ' + + APPL_NAME + ' (version ' + + VersionHi + '.' + VersionLo + ').' + #13 + + 'Some data could not be loaded.', + mtWarning, [mbOk], 0) + else + MessageDlg (Filename + ' has an unknown format. ' + + 'Some data could not be loaded.', + mtWarning, [mbOk], 0); + end; + + if Tab.Tabs.Count = 0 then + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + Tab.TabIndex := 0; + TabChange (nil); + UpdateTileBitmap; + SetEditorMode (mTile); + + DrawUsedFromToList; + + if (BackColor <> -1) then + SetBackgroundColor (BackColor, TRUE); + + AddFileToRecentProjects (FileName); + end; + + case aaN of + 2: aa2.Click; + 3: aa3.Click; + 4: aa4.Click; + else + aaOff.Click; + end; + + ProgressPanel.Visible := FALSE; + Modified := Unknown; + +{$IFDEF SHOWTOTALTIME} + ShowMessage ('Total time: ' + Format (' %1.5f ', [DtTm]) + + ' in ' + IntToStr (Sessions) + ' session(s)'); +{$ENDIF} + + end; + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; + if ShowInfo then + if (Info.Startup.Checked) then + ProjectInformation1Click(Sender); + FitInWindow1Click (Sender); +end; + +procedure TMainForm.CloseAll; +begin + { SetEditorMode (mTile); } + ClearUndo; + while Tab.TabIndex > -1 do + RemoveTileSet1Click (nil); + SetLength (FromToSave, 0); + Modified := FALSE; + Filename := ''; + OutputPath := ''; + CodeGen.LastDef := ''; + StartTime := Now; + Sessions := 0; + + PaletteManager.ClearPalettes; + + SelectOutputDirectory1.Checked := FALSE; + OutputtoProjectDirectory1.Checked := TRUE; + + with Lists do + Notes.Text := ''; + + with Info do + begin + Author.Text := ''; + Notes.Text := ''; + Copyright.Text := ''; + Startup.Checked := FALSE; + end; + + aaOff.Click; +end; + +function TMainForm.SaveChanges: Boolean; +begin + SaveChanges := FALSE; + if Modified then + begin + case MessageDlg ('Save changes to ' + ProjectName + '?', + mtConfirmation, [mbYes, mbNo, mbCancel], 0) of + mrYes: + begin + Save1Click (nil); + if Modified then + Exit; + end; + mrCancel: + Exit; + end; + end; + SaveChanges := TRUE; +end; + +procedure TMainForm.NewGame1Click(Sender: TObject); +begin + if Modified then + if not SaveChanges then + Exit; + CloseAll; + + CreateNewTileCollection (NewTCName, 32, 32, TRUE); + + SetEditorMode (mTile); // 2.43 bug fix: access violation + + StartEdit (TRUE); + + Filename := ''; + Application.Title := APPL_NAME + ' - ' + ProjectName; + MainForm.Caption := Application.Title; +end; + +procedure TMainForm.ToggleAnimation; +begin + if Animate1.Checked then + begin + with TileTab[Tab.TabIndex] do + begin + if AnimStart = AnimEnd then + begin + AnimStart := -1; + AnimEnd := -1; + end; + if AnimStart = -1 then + AnimStart := 0; + if (AnimEnd = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimEnd := tbr.TileCount - 1; + if AnimStart = AnimEnd then + Animate1.Checked := FALSE; + end; + end; +end; + +procedure TMainForm.Animate1Click(Sender: TObject); +begin + Animate1.Checked := not Animate1.Checked; + ToggleAnimation; + + AnimationTimer.Enabled := Animate1.Checked; + + + if Animate1.Checked then + AnimateButton.Style := tbsCheck + else + AnimateButton.Style := tbsButton; + AnimateButton.Down := Animate1.Checked; + AnimateButton.Refresh; + +end; + + + +procedure TMainForm.FirstFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + AnimStart := tbr.Current; +end; + +procedure TMainForm.LastFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + AnimEnd := tbr.Current; +end; + +procedure TMainForm.NextFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + begin + if (AnimStart = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimStart := 0; + if (AnimEnd = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimEnd := tbr.TileCount - 1; + if tbr.Current + 1 <= AnimEnd then + Inc (tbr.Current) + else + tbr.Current := AnimStart; + end; + StartEdit (FALSE); + DrawCursor; +end; + +procedure TMainForm.PreviousFrame1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex] do + begin + if (AnimStart = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimStart := 0; + if (AnimEnd = -1) or (AnimEnd > tbr.TileCount - 1) then + AnimEnd := tbr.TileCount - 1; + if tbr.Current - 1 >= AnimStart then + Dec (tbr.Current) + else + tbr.Current := AnimEnd; + end; + StartEdit (FALSE); + DrawCursor; +end; + +procedure TMainForm.AnimationTimerTimer(Sender: TObject); +begin + // if AllowTimer then + begin + + if Drawing then + begin + TileMouseUp (Sender, mbLeft, ShiftState, LastX, LastY); + + NextFrame1Click (Sender); + + TileMouseDown (Sender, mbLeft, ShiftState, LastX, LastY); + end + else + NextFrame1Click (Sender); + + end; +end; + +procedure TMainForm.Default1Click(Sender: TObject); +begin + AnimationTimer.Interval := DEFAULT_ANIMATION_SPEED; +end; + +procedure TMainForm.Faster1Click(Sender: TObject); + var + i: Integer; +begin + if AnimationTimer.Enabled then + begin + i := AnimationTimer.Interval; + Dec (i, 5 + i div 10); + if i < 25 then + i := 25; + AnimationTimer.Interval := i; + end; +end; + +procedure TMainForm.Slower1Click(Sender: TObject); + var + i: Integer; +begin + if AnimationTimer.Enabled then + begin + i := AnimationTimer.Interval; + Inc (i, 5 + i div 10); + if i > 1500 then + i := 1500; + AnimationTimer.Interval := i; + end; +end; + +procedure TMainForm.TileModeButtonClick(Sender: TObject); +begin + SetEditorMode (mTile); +end; + +procedure TMainForm.MapModeButtonClick(Sender: TObject); +begin + SetEditorMode (mMap); +end; + +procedure TMainForm.ConverttoTileSequence1Click(Sender: TObject); + var + i, j, m, n: Integer; + mcr: MapCellRec; +begin + if Mode = mMap then + begin + if not Selection then + Exit; + + // check if not empty + n := 0; + m := 0; // frame lengths provided as map codes? + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if mcr.MapCode > m then + m := mcr.MapCode; + if not EmptyMCR (mcr) then + Inc (n); + end; + + if n < 1 then + Exit; + + SeqW := n; + SeqH := 1; + NewSeqMap (TileTab[Tab.TabIndex].tbr, SeqW, SeqH); + + n := SeqTab.Tabs.Count; + SeqTab.TabIndex := SeqTab.Tabs.Add (IntToStr (n)); + seq := SelectSeqMap (TileTab[Tab.TabIndex].tbr, n); + + n := 0; + with Area do + begin + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if not EmptyMCR (mcr) then + begin +// if m = 0 then +// mcr.MapCode := 25; + seq^.Map[0, n] := mcr; + Inc (n); + end; + end; + end; + + SeqTabChange (Sender); + + { RD: clear selection } + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end; +end; + +procedure TMainForm.SeqTabChange(Sender: TObject); +begin + SeqTimer.Enabled := FALSE; + + if SeqTab.TabIndex < 0 then + begin + seq := nil; + SeqBitmap.Visible := FALSE; + SeqTimer.Enabled := FALSE; + + Exit; + end; + seq := SelectSeqMap (TileTab[Tab.TabIndex].tbr, SeqTab.TabIndex); + if seq <> nil then + begin + + SeqH := Length (seq^.map); + if SeqH > 0 then + begin + SeqW := Length (seq^.map[0]); + + SeqBitmap.Width := W; + SeqBitmap.Height := H; + ResizeBitmap (SeqBitmap); + SeqBitmap.Left := (SeqTab.ClientWidth - W) div 2; + SeqBitmap.Top := 8; // (SeqTab.ClientHeight - H) div 2; + + SeqBitmap.Visible := TRUE; + + (* + { RD: draw sequence map } + DrawMap (Rect (0, 0, -1, -1), FALSE, FALSE, TRUE); + *) + + // 2.5 draw first frame right away + SeqFrame := SeqW; + SeqTimerTimer (nil); + + SeqTimer.Interval := Seq^.map[0, 0].MapCode * 10 + 1; + SeqTimer.Enabled := TRUE; + end; + end; + + Modified := TRUE; + MapTab.SetFocus; +end; + +procedure TMainForm.SeqTimerTimer(Sender: TObject); + var + mcr: MapCellRec; + OldSel: Boolean; +begin + // draw frame and set timer for next + + if SkipDraw then + begin + SeqTimer.Interval := 10; + SeqTimer.Enabled := TRUE; + end + else + begin + Inc (SeqFrame); + if SeqFrame >= SeqW then + SeqFrame := 0; + + if (Seq <> nil) + and (Length (Seq^.map) > 0) + and (Length (Seq^.map[0]) > SeqFrame) then + begin + mcr := Seq^.map[0, SeqFrame]; + + OldSel := Selection; + Selection := FALSE; + { RD: draw tile from sequence } + DrawMap (Rect (SeqFrame, 0, SeqFrame, 0), FALSE, FALSE, TRUE); + Selection := OldSel; + + SeqTimer.Interval := mcr.MapCode * 10 + 1; + SeqTimer.Enabled := TRUE; + end; + end; +end; + + +// if the BMP file header was not correctly written to disk, correct it +procedure PatchBMPFile (FileName: string); + var + F: file; + Buffer: array of Char; + Size, Diff, HS: Integer; + s: string; +begin + AssignFile (F, FileName); + Reset (F, 1); + Size := FileSize (F); + SetLength (Buffer, Size); + BlockRead (F, Buffer[0], Size); + CloseFile (F); + + HS := StrInt (Buffer[2] + Buffer[3] + Buffer[4] + Buffer[5]); + if HS <> Size then + if MessageDlg ('The BMP file has not been saved correctly. Correct header?', + mtWarning, [mbYes, mbNo], 0) = mrYes then + begin + if HS > Size then + ShowMessage ('Cannot correct header') + else + begin + Diff := Size - HS; + s := IntStr (Size); + Buffer[2] := s[1]; + Buffer[3] := s[2]; + Buffer[4] := s[3]; + Buffer[5] := s[4]; + s := IntStr (StrInt (Buffer[10] + Buffer[11] + Buffer[12] + Buffer[13]) + Diff); + Buffer[10] := s[1]; + Buffer[11] := s[2]; + Buffer[12] := s[3]; + Buffer[13] := s[4]; + DeleteFile (FileName); + AssignFile (F, FileName); + ReWrite (F, 1); + BlockWrite (F, Buffer[0], Size); + CloseFile (F); + end; + end; + + SetLength (Buffer, 0); +end; + + +procedure TMainForm.RemoveTileSequence1Click(Sender: TObject); + var + i, j: Integer; +begin + if SeqTab.TabIndex > -1 then + begin + RemoveSeq (TileTab[Tab.TabIndex].tbr, SeqTab.TabIndex); + Modified := TRUE; + with SeqTab do + begin + j := TabIndex; + Tabs.Delete (TabIndex); + for i := j to Tabs.Count - 1 do + Tabs.Strings[i] := IntToStr (StrToInt (Tabs.Strings[i]) - 1); + if j <= Tabs.Count - 1 then + TabIndex := j + else + TabIndex := Tabs.Count - 1; + end; + SeqTabChange (Sender); + UpdateMapRegion (Rect(0, 0, -1, -1)); + Modified := TRUE; + end +end; + +procedure TMainForm.InsertTileSequence1Click(Sender: TObject); + var + i, j: Integer; +begin + if (Mode = mMap) and Selection and (SeqTab.TabIndex > -1) then + begin + if Selection then + begin + for j := Area.Top to Area.Bottom do + for i := Area.Left to Area.Right do + begin + with lmp^.Map[j, i] do + begin + Back := -1; + Mid := -1; + Front := -1; + MapCode := SeqTab.TabIndex; + // Bounds := $FF; + // Bounds := ShortInt (Bounds or $80); + Bounds := ShortInt (Bounds or $40); // 2.55 + end; + end; + Modified := TRUE; + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end; + end; +end; + +procedure TMainForm.PreviousPattern1Click(Sender: TObject); +begin + if FromToSavePos > 0 then + Dec (FromToSavePos) + else + FromToSavePos := Length (FromToSave) - 1; + if FromToSavePos >= 0 then + SelectSavedFromToList; +end; + +procedure TMainForm.NextPattern1Click(Sender: TObject); +begin + if FromToSavePos < Length (FromToSave) - 1 then + Inc (FromToSavePos) + else + FromToSavePos := 0; + SelectSavedFromToList; +end; + +procedure TMainForm.SelectSavedFromToList; +{ var + i, R, G, B: Integer; } +begin + if FromToSavePos < Length (FromToSave) then + with FromToSave[FromToSavePos] do + begin + FromToList := FT; + ExFromToList := EXFT; + { + for i := 0 to MAX_FROM_TO - 1 do + begin + R := LimitRGB (EXFT[i, 0]); + G := LimitRGB (EXFT[i, 1]); + B := LimitRGB (EXFT[i, 2]); + FromToList[i] := RGB (R, G, B); + end; + } + FromToFirst := F; + FromToLast := L; + FromTo.Repaint; + end; +end; + +function TMainForm.FindCurrentColorPattern (FindColor: Integer; All: Boolean): Integer; + var + i, j, k, diff: Integer; + FTF, FTL: Integer; +begin + for k := Length (FromToSave) - 1 downto 0 do + with FromToSave[k] do + begin + FindCurrentColorPattern := k; + + if (FindColor <> -1) then // 2.53 + begin + FTF := FromToSave[k].F; + FTL := FromToSave[k].L; + if All then + begin + FTF := 0; + FTL := MAX_FROM_TO - 1; + end; + for i := FTF to FTL do + if FT[i] = FindColor then + begin + if (not (ssAlt in LastShift)) then + begin + FromToFirst := i; + FromToLast := i; + end; + Exit; + end; + end + else + begin + diff := byte ((FromToSave[k].F <> FromToFirst) or + (FromToSave[k].L <> FromToLast)); + for i := 0 to MAX_FROM_TO - 1 do + for j := 0 to 2 do + if EXFT[i, j] <> ExFromToList[i, j] then + Inc (diff); + if diff = 0 then + Exit; + end; + end; + FindCurrentColorPattern := -1; +end; + +procedure TMainForm.FindPatternForColor; +begin + +end; + +procedure TMainForm.AddColorPattern1Click(Sender: TObject); +begin + if FindCurrentColorPattern (-1, FALSE) > -1 then + Exit; + SetLength (FromToSave, Length (FromToSave) + 1); + FromToSavePos := Length (FromToSave) - 1; + with FromToSave[FromToSavePos] do + begin + FT := FromToList; + EXFT := ExFromToList; + F := FromToFirst; + L := FromToLast; + end; + DrawUsedFromToList; + Modified := TRUE; +end; + +procedure TMainForm.DrawUsedFromToList; + var + bmp: TBitmap; + x, y: Integer; +begin + bmp := TBitmap.Create; + SetStretchBltMode(bmp.Canvas.Handle, HALFTONE); + with bmp do + begin + PixelFormat := pf24bit; + width := MAX_FROM_TO; + height := Length (FromToSave); + + for y := 0 to height - 1 do + for x := 0 to MAX_FROM_TO - 1 do + begin + Canvas.Pixels[x, y] := ColorPatternsPanel.Color; + if FromToSave[y].F < FromToSave[y].L then + begin + if (x >= FromToSave[y].F) and (x <= FromToSave[y].L) then + Canvas.Pixels[x, y] := FromToSave[y].FT[x]; + end + else + if (x >= FromToSave[y].L) and (x <= FromToSave[y].F) then + Canvas.Pixels[x, y] := FromToSave[y].FT[MAX_FROM_TO - 1 - x]; + end; + + ColorPatternsImage.Picture.Bitmap := bmp; + ColorPatternsImage.Stretch := TRUE; + bmp.Free; + end; +end; + +procedure TMainForm.RemoveColorPattern1Click(Sender: TObject); + var + i: Integer; +begin + i := FindCurrentColorPattern (-1, FALSE); + if i = -1 then + Exit + else + FromToSavePos := i; + if FromToSavePos < Length (FromToSave) then + begin + for i := FromToSavePos + 1 to Length (FromToSave) - 1 do + FromToSave[i - 1] := FromToSave[i]; + SetLength (FromToSave, Length (FromToSave) - 1); + if FromToSavePos >= Length (FromToSave) then + FromToSavePos := 0; + SelectSavedFromToList; + end; + Modified := TRUE; +end; + + + + var + itab, imap, itile, itstile, { itinytile, } idat, + iseq, iseqdat, ipal, ipaldat: Integer; + itilemap, icorner, icornerdat, // 2.4 + itmpdat, + ihedge, ihedgedat, + ivedge, ivedgedat, + itile0: Integer; + + iutt: Integer; // 2.5 + + itb: Integer; // 2.54 + + ifile: Integer; // 3.00 (input file text line / bin pos) + + +procedure TMainForm.Generate1Click(Sender: TObject); + + type + TVarType = (vtNum, vtStr); + TVarRec = + record + Name: string; + case vt: TVarType of + vtNum: (Num: Integer); + vtStr: (Str: string[255]); // 2.0 + end; + + const + ExprChars = [' ', '+', '-', '*', '/', '(', ')', '&', '|', '%', '!']; + + // 2.4 + const + EdgesX: array[0..7] of Integer = (-1, 0, 1, -1, 1, -1, 0, 1); + EdgesY: array[0..7] of Integer = (-1, -1, -1, 0, 0, 1, 1, 1); + EdgeToCorner: array[0..7] of Integer = (3, -1, 2, -1, -1, 1, -1, 0); + CornerToEdge: array[0..3] of Integer = (0, 2, 5, 7); + + var + EdgeSrc: array[0..7] of TRect; + EdgeDst: array[0..7] of TRect; + TileCornerX: array[0..3] of Integer; + TileCornerY: array[0..3] of Integer; + TmpCorner: array[0..3] of Integer; + + type + CornerRec = + record + Tiles: array[0..3] of Integer; + Count: Integer; + Colors: array[0..3] of Integer; + Number: Integer; + Used: Boolean; + end; + + EdgeRec = + record + Tiles: array[0..1] of Integer; + Count: Integer; + end; + + var + Corners: array of array of CornerRec; + HEdges: array of array of EdgeRec; + VEdges: array of array of EdgeRec; + + type + FlipType = (NOFLIP, HFLIP, VFLIP, HVFLIP); + FlipInts = array[FlipType] of Integer; + + var + ValidTileSet: Boolean; + ValidTSTileSet: Boolean; // 3.0 + + VarList: array of TVarRec; + + aMCR: array of array of MapCellRec; + aFinalRef: array of array of Integer; + bmpFinal: array of TBitmap; + bmpAlpha: array of TBitmap; // 2.5 + aFinalTileCount: array of Integer; + bmpCurTile: TBitmap; // 2.54 + CurRGB: Integer; + DataW, DataH: Integer; + + // 2.4 + TexTiles: Boolean; + bmpTexTiles: array of TBitmap; + bmpTexAlpha: array of TBitmap; // 2.5 + aMCRSur: array of array of array[0..7] of array of Integer; + aSameAs: array of array of array[0..7] of Integer; + aTrans: array of array of array[0..7] of Integer; + aCornerCount: array of Integer; + aHEdgeCount: array of Integer; + aVEdgeCount: array of Integer; + + // 2.5 - UniuqeTexTiles + UTT: Boolean; + aUTTRef: array of array of array of array[0..8] of Integer; + aUTTIndex: array of array of Integer; + aUTTCount: array of Integer; + aTransTile: array of Integer; + + // 2.2 + TinyTiles: Boolean; + aFinalTinyTileCount: array of FlipInts; + aFinalTinyTiles: array of array[FlipType] of array of Integer; + aFinalTinyRef: array of array of FlipInts; + TinyW, TinyH: Integer; + TinyNH, TinyNV: Integer; + TinyFlip: FlipType; + + code: string; + Error: Boolean; + MapWd, MapHt, tmpW, tmpH: Integer; + SeqLen: Integer; + // crc: string; + TransX, TransY: array of Integer; + NumericExpr: Boolean; // all variables used are numbers? + TransReplace: string; // 2.0 + Quote: Boolean; // 2.1 + + // 2.5 + aa: Boolean; + aaX, aaY: Integer; + + // 3.0 + SeqFrames: Integer; + + // options + StartWithEmptyTile: Boolean; + ExportDuplicateTiles: Boolean; // ignore unique tile check + + RunCMDLine: string; // run command line + + const + MAX_COUNTER = 100; + + var + Counters: array[0..MAX_COUNTER] of LongInt; + ReadingAhead: Boolean; + + + + function GetTinyNH: Integer; + begin + if TinyTiles then + GetTinyNH := TinyNH + else + GetTinyNH := 1; + end; + + function GetTinyNV: Integer; + begin + if TinyTiles then + GetTinyNV := TinyNV + else + GetTinyNV := 1; + end; + + + procedure SetNumVar (ID: string; Value: Integer); + var + i: Integer; + begin + ID := UpCaseStr (ID); + for i := 0 to Length (VarList) - 1 do + if VarList[i].Name = ID then + begin + VarList[i].vt := vtNum; + VarList[i].Num := Value; + Exit; + end; + SetLength (VarList, Length (VarList) + 1); + i := Length (VarList) - 1; + VarList[i].Name := ID; + VarList[i].vt := vtNum; + VarList[i].Num := Value; + end; + + procedure SetStrVar (ID: string; Value: string); + var + i: Integer; + begin + ID := UpCaseStr (ID); + for i := 0 to Length (VarList) - 1 do + if VarList[i].Name = ID then + begin + VarList[i].vt := vtStr; + VarList[i].Str := Value; + Exit; + end; + SetLength (VarList, Length (VarList) + 1); + i := Length (VarList) - 1; + VarList[i].Name := ID; + VarList[i].vt := vtStr; + VarList[i].Str := Value; + end; + + function AddLeadingZeros (s, Fmt: string): string; + var + p: Integer; + begin + p := Pos ('%0', Fmt); + if p > 0 then + while (p < Length (s)) and (s[p] = ' ') do + begin + s[p] := '0'; + Inc (p); + end; + AddLeadingZeros := s; + end; + + function GetVarValue (ID, Fmt: string): string; + var + i: Integer; + s: string; + N: LongInt; + begin + s := UpCaseStr (ID); + for i := 0 to Length (VarList) - 1 do + if VarList[i].Name = s then + case VarList[i].vt of + vtStr: + begin + // if (s <> 'SHR') and (s <> 'SHL') then + if (Pos (' ' + s + ' ', ' SHR SHL IF THEN ELSE NOT EQUALS ABOVE BELOW ') <= 0) then + NumericExpr := FALSE; + GetVarValue := VarList[i].Str; + Exit; + end; + vtNum: + begin + s := Format (Fmt, [VarList[i].Num]); + GetVarValue := AddLeadingZeros (s, Fmt); + Exit; + end; + end; + + if (Copy (s, 1, 7) = 'COUNTER') and (Length (s) > 7) then // 3.0 + begin + Delete (s, 1, 7); + Val (s, N, i); + if (i = 0) and (N <= MAX_COUNTER) then + begin + i := N; + N := Counters[i]; + s := Format (Fmt, [N]); + if not ReadingAhead then + Inc (Counters[i]); + GetVarValue := AddLeadingZeros (s, Fmt); + Exit; + end; + end; + + { + MessageDlg ('Error in code generation definition: uninitialized variable (' + + ID + ').', mtError, [mbOk], 0); + } + Error := TRUE; + GetVarValue := ''; + end; + + + + + + procedure GetTinyPos (itab, p: Integer; var x, y: Integer); + var + NH: Integer; + TileNo, TileX, TileY: Integer; + begin + if p = -1 then // transparant + begin + x := -1; + y := -1; + end + else + with TileTab[itab] do + begin + NH := bmpFinal[itab].Width div tbr.W; + TileNo := p div (TinyNH * TinyNV); + p := p mod (TinyNH * TinyNV); + TileX := TileNo mod NH; + TileY := TileNo div NH; + x := TileX * tbr.W + (p mod TinyNH) * TinyW; + y := TileY * tbr.H + (p div TinyNH) * TinyH; + end; + end; + + // 2.2 + procedure SetupTinyTiles (W, H: Integer; F: FlipType); + var + itab: Integer; + + const + EmptyFlipInt: FlipInts = (0, 0, 0, 0); + + + function FindTinyTile (P: Integer; F: FlipType): Integer; + var + n: Integer; + PX, PY: Integer; + x, y, i, j: Integer; + Diff: Boolean; + Found: Integer; + begin + Found := -1; + if P <> -1 then + with TileTab[itab] do + begin + GetTinyPos (itab, P, PX, PY); + for n := 0 to aFinalTinyTileCount[itab][F] - 1 do + if Found = -1 then + begin + GetTinyPos (itab, aFinalTinyTiles[itab][TinyFlip][n], + x, y); + + Diff := FALSE; + for j := 0 to TinyH - 1 do + for i := 0 to TinyW - 1 do + if not Diff then + if (x = -1) or (y = -1) then + begin + if (bmpFinal[itab].Canvas.Pixels[PX + i, PY + j]) <> TRANS_COLOR then + Diff := TRUE; + end + else + begin + if (bmpFinal[itab].Canvas.Pixels[PX + i, PY + j]) <> + (bmpFinal[itab].Canvas.Pixels[x + i, y + j]) then + Diff := TRUE; + end; + + if not Diff then + Found := n; // aFinalTinyTiles[itab][TinyFlip][n]; + end; + end; + FindTinyTile := Found; + end; + + function AddTinyTile (i: Integer; F: FlipType): Integer; + var + n, l: Integer; + begin + n := FindTinyTile (i, F); + if (n = -1) then + begin + l := aFinalTinyTileCount[itab][F]; + Inc (aFinalTinyTileCount[itab][F]); + SetLength (aFinalTinyTiles[itab][F], l + 1); + aFinalTinyTiles[itab][F][l] := i; + n := l; + end; + AddTinyTile := n; + end; + + var + i: Integer; + + begin { SetupTinyTiles } + TinyFlip := F; + if (W = TinyW) and (H = TinyH) then + Exit; + + TinyW := W; + TinyH := H; + + for itab := 0 to Tab.Tabs.Count - 1 do + begin + SetLength (aFinalTinyTiles[itab][NOFLIP], 0); + SetLength (aFinalTinyTiles[itab][HFLIP], 0); + SetLength (aFinalTinyTiles[itab][VFLIP], 0); + SetLength (aFinalTinyTiles[itab][HVFLIP], 0); + + SetLength (aFinalTinyRef[itab], 0); + end; + + for itab := 0 to Tab.Tabs.Count - 1 do + with TileTab[itab] do + begin + aFinalTinyTileCount[itab] := EmptyFlipInt; + if (W > 0) and (tbr.W mod W = 0) and + (H > 0) and (tbr.H mod H = 0) then + begin + TinyNH := tbr.W div W; + TinyNV := tbr.H div H; + + SetLength (aFinalTinyRef[itab], + aFinalTileCount[itab] * TinyNH * TinyNV); + + AddTinyTile (-1, NOFLIP); // add empty tile + for i := 0 to aFinalTileCount[itab] * TinyNH * TinyNV - 1 do + aFinalTinyRef[itab][i][TinyFlip] := AddTinyTile (i, NOFLIP); + end; + end; + end; + + + procedure ShowProgress (Pos, Max: Integer); + begin + ProgressBar.Position := 100 * itab + Pos * 100 div Max; + end; + + function FindMCR (const mcr: MapCellRec): Integer; // -1: not found + var + i: Integer; + begin + for i := 0 to Length (aMCR[itab]) - 1 do + if (aMCR[itab][i].Back = mcr.Back) and + (aMCR[itab][i].Mid = mcr.Mid) and + (aMCR[itab][i].Front = mcr.Front) then + begin + FindMCR := i; + Exit; + end; + FindMCR := -1; + end; + + procedure AddMCR (const mcr: MapCellRec); + var + i: Integer; + Found: Boolean; + begin + i := FindMCR (mcr); + // Found := (i > -1) or (mcr.Bounds = $FF); // skip sequence + Found := (i > -1) or (mcr.Bounds and $40 <> 0); // skip sequence + if not Found then + begin + i := Length (aMCR[itab]); + SetLength (aMCR[itab], i + 1); + aMCR[itab][i] := mcr; + end; + end; + + procedure AddMCRs (const aaMaps: aaMapCellRec); + var + i, j: Integer; + begin + for j := 0 to Length (aaMaps) - 1 do + for i := 0 to Length (aaMaps[j]) - 1 do + AddMCR (aaMaps[j, i]); + end; + + + + procedure AddEdge (Edge: Integer; const mcr, mcr2: MapCellRec); + var + i, j, k, l: Integer; + Found: Boolean; + begin + j := FindMCR (mcr); + if j > -1 then + begin + j := aFinalRef[itab][j]; + + k := FindMCR (mcr2); + if k > -1 then + k := aFinalRef[itab][k]; + + Found := FALSE; + l := Length (aMCRSur[itab][j][Edge]); + for i := 0 to l - 1 do + if i mod 2 = 0 then + if aMCRSur[itab][j][Edge][i] = k then + begin + Inc (aMCRSur[itab][j][Edge][i + 1]); + Found := TRUE; + end; + if not Found then + begin + SetLength (aMCRSur[itab][j][Edge], l + 2); + aMCRSur[itab][j][Edge][l] := k; + aMCRSur[itab][j][Edge][l + 1] := 1; + end; + + end; + end; + + + procedure AddAllEdges (Edge: Integer; const mcr, mcr2: MapCellRec; const Seq: MapSet); + var + i, j: Integer; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + // if mcr2.Bounds <> $FF then + if mcr2.Bounds and $40 = 0 then + AddEdge (Edge, mcr, mcr2) + else + for i := 0 to Length (Seq.aMaps[mcr2.MapCode].Map[0]) - 1 do + AddEdge (Edge, mcr, Seq.aMaps[mcr2.MapCode].Map[0, i]) + else + // if mcr2.Bounds <> $FF then + if mcr2.Bounds and $40 = 0 then + for j := 0 to Length (Seq.aMaps[mcr.MapCode].Map[0]) - 1 do + AddEdge (Edge, Seq.aMaps[mcr.MapCode].Map[0, j], mcr2) + else + if mcr.MapCode = mcr2.MapCode then // 2.43 + begin + for i := 0 to Length (Seq.aMaps[mcr.MapCode].Map[0]) - 1 do + AddEdge (Edge, Seq.aMaps[mcr.MapCode].Map[0, i], + Seq.aMaps[mcr2.MapCode].Map[0, i]); + end + else + for j := 0 to Length (Seq.aMaps[mcr.MapCode].Map[0]) - 1 do + for i := 0 to Length (Seq.aMaps[mcr2.MapCode].Map[0]) - 1 do + AddEdge (Edge, Seq.aMaps[mcr.MapCode].Map[0, j], + Seq.aMaps[mcr2.MapCode].Map[0, i]) + end; + + + procedure AddCorner (const mcr0, mcr1, mcr2, mcr3: MapCellRec); + var + CR: CornerRec; + i, j, L: Integer; + begin + CR.Tiles[0] := FindMCR (mcr0); + CR.Tiles[1] := FindMCR (mcr1); + CR.Tiles[2] := FindMCR (mcr2); + CR.Tiles[3] := FindMCR (mcr3); + + j := -1; + L := Length (Corners[itab]); + for i := 0 to L - 1 do + with Corners[itab][i] do + if (CR.Tiles[0] = Tiles[0]) and + (CR.Tiles[1] = Tiles[1]) and + (CR.Tiles[2] = Tiles[2]) and + (CR.Tiles[3] = Tiles[3]) then + j := i; + + if j <> -1 then + Inc (Corners[itab][j].Count) + else + begin + CR.Count := 1; + CR.Used := FALSE; + SetLength (Corners[itab], L + 1); + Corners[itab][L] := CR; + end; + end; + + + procedure AddAllCorners (const mcr0, mcr1, mcr2, mcr3: MapCellRec; const Seq: MapSet); + + function GetCount (const mcr: MapCellRec): Integer; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := 1 + else + Result := Length (Seq.aMaps[mcr.MapCode].Map[0]); + end; + + function GetMCR (const mcr: MapCellRec; N: Integer): MapCellRec; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := mcr + else + Result := Seq.aMaps[mcr.MapCode].Map[0][N]; + end; + + + var + i, j, k, l: Integer; + begin + for i := 0 to GetCount (mcr0) - 1 do + for j := 0 to GetCount (mcr1) - 1 do + for k := 0 to GetCount (mcr2) - 1 do + for l := 0 to GetCount (mcr3) - 1 do + AddCorner (GetMCR (mcr0, i), + GetMCR (mcr1, j), + GetMCR (mcr2, k), + GetMCR (mcr3, l)); + end; + + + procedure CreateEdgeData (const aaMaps: aaMapCellRec; const Seq: MapSet); + var + W, H, X, Y: Integer; + i, j, edge: Integer; + begin + H := Length (aaMaps); + for j := 0 to H - 1 do + begin + W := Length (aaMaps[j]); + for i := 0 to W - 1 do + begin + + for edge := 0 to 7 do + if EdgeToCorner[edge] = -1 then + begin + X := (i + EdgesX[edge] + W) mod W; + Y := (j + EdgesY[edge] + H) mod H; + AddAllEdges (edge, aaMaps[j, i], aaMaps[Y, X], Seq); + end; + + X := (i + 1) mod W; + Y := (j + 1) mod H; + AddAllCorners (aaMaps[j, i], aaMaps[j, X], aaMaps[Y, i], aaMaps[Y, X], Seq); + + end; + end; + end; + + + + function GetTransCount (tile, edge: Integer): Integer; + var + i, j, k: Integer; + Y: Integer; + begin + k := 0; + with TileTab[itab].tbr do + Y := (tile - 1) * (H + 2); + with bmpTexTiles[itab].Canvas do + with EdgeSrc[edge] do + for j := top to bottom - 1 do + for i := left to right - 1 do + if (Y < 0) or (Pixels[i, Y + j] = TRANS_COLOR) then + Inc (k); + Result := k; + end; + + + function CompareEdge (tile1, tile2, edge: Integer): Boolean; + var + i, j: Integer; + Y1, Y2: Integer; + begin + Result := FALSE; + with TileTab[itab].tbr do + begin + Y1 := (tile1 - 1) * (H + 2); + Y2 := (tile2 - 1) * (H + 2); + end; + with bmpTexTiles[itab].Canvas do + with EdgeSrc[7 - edge] do + for j := top to bottom - 1 do + for i := left to right - 1 do + if Pixels[i, Y1 + j] <> Pixels[i, Y2 + j] then + Exit; + + Result := TRUE; + end; + + + procedure FindSameEdges; + var + i, tile, edge, N: Integer; + begin + for tile := 0 to Length (aMCRSur[itab]) - 1 do + for edge := 0 to 7 do + aTrans[itab][tile][edge] := GetTransCount (tile, edge); + + for edge := 0 to 7 do + if EdgeToCorner[edge] = -1 then + begin + N := Length (aMCRSur[itab]); + for tile := 0 to N - 1 do + begin + i := tile - 1; + while (i >= 0) and (not CompareEdge (i, tile, edge)) do + Dec (i); + aSameAs[itab][tile][edge] := i; + end; + end; + end; + + + + // 2.5 + + function CompareAllEdges (tile: Integer; sur1, sur2: Integer): Boolean; + var + t1, t2: Integer; + edge: Integer; + i: Integer; + + begin + Result := FALSE; + for edge := 0 to 7 do + begin + t1 := aUTTRef[itab][tile][sur1][edge]; + t2 := aUTTRef[itab][tile][sur2][edge]; + + if t1 <> t2 then + if EdgeToCorner[edge] = -1 then + begin + if not CompareEdge (t1, t2, edge) then + Exit; + end + else + begin + for i := 0 to 3 do + if Corners[itab][t1].Colors[i] <> Corners[itab][t2].Colors[i] then + Exit; + end; + end; + + Result := TRUE; + end; + + + function FindCorner (t0, t1, t2, t3: Integer): Integer; + var + i: Integer; + begin + Result := -1; + + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if (t0 = Tiles[0]) and + (t1 = Tiles[1]) and + (t2 = Tiles[2]) and + (t3 = Tiles[3]) then + Result := i; + end; + + + function AddTileCombination (tile: Integer; surtiles: array of Integer): SmallInt; + var + i, j, l, t: Integer; + Same, Found: Boolean; + begin + Result := tile; + if tile <= 0 then + Exit; + + { ((0, 1, 0, 1, 1, 0, 1, 1, 3), (0, 1, 0, 1, 1, 1, 2, 2, 4), (0, 1, 0, 1, 1, 2, 1, 0, 5), + (0, 1, 1, 1, 2, 0, 1, 3, 6), (2, 1, 0, 2, 1, 4, 1, 0, 7), + (0, 1, 3, 1, 1, 0, 1, 0, 8), (3, 2, 4, 1, 1, 0, 1, 0, 9), (4, 1, 0, 1, 1, 0, 1, 0, 10)) } + + surtiles[0] := FindCorner (surtiles[0], surtiles[1], surtiles[3], tile); + surtiles[2] := FindCorner (surtiles[1], surtiles[2], tile, surtiles[4]); + surtiles[5] := FindCorner (surtiles[3], tile, surtiles[5], surtiles[6]); + surtiles[7] := FindCorner (tile, surtiles[4], surtiles[6], surtiles[7]); + + for i := 0 to Length (aUTTRef[itab][tile]) - 1 do + begin + Same := TRUE; + for j := 0 to 7 do + if surtiles[j] <> aUTTRef[itab][tile][i][j] then + Same := FALSE; + if Same then + begin + Result := aUTTRef[itab][tile][i][8]; + Exit; + end; + end; + + Found := FALSE; + for j := 0 to 7 do + begin + l := Length (aMCRSur[itab][tile][j]); + for i := 0 to l - 1 do + if i mod 2 = 0 then + begin + t := aMCRSur[itab][tile][j][i]; + { if EdgeToCorner[j] <> -1 then + t := corners[itab][t].Tiles[3 - EdgeToCorner[j]]; } + + if t = surtiles[j] then + Found := TRUE; + end; + end; + if not Found then + Exit; + + l := Length (aUTTRef[itab][tile]); + SetLength (aUTTRef[itab][tile], l + 1); + for j := 0 to 7 do + aUTTRef[itab][tile][l][j] := surtiles[j]; + + Found := FALSE; + for i := 0 to l - 1 do + if not Found then + if CompareAllEdges (tile, i, l) then + begin + t := aUTTRef[itab][tile][i][8]; + aUTTRef[itab][tile][l][8] := t; + Result := t; + Found := TRUE; + end; + if not Found then + begin + i := aUTTCount[itab]; + aUTTRef[itab][tile][l][8] := i + 1; + SetLength (aUTTIndex[itab], i + 1); + + aUTTIndex[itab][i] := tile; + Inc (aUTTCount[itab]); + Result := i + 1; + end; + end; + + + procedure CreateUTTData (const aaMaps: aaMapCellRec; const Seq: MapSet); + var + W, H, X, Y: Integer; + i, j, edge: Integer; + aMCR: array[0..7] of MapCellRec; + + function AddAllCombinations (mcr: MapCellRec): SmallInt; + + function GetCount (const mcr: MapCellRec): Integer; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := 1 + else + Result := Length (Seq.aMaps[mcr.MapCode].Map[0]); + end; + + function GetMCR (const mcr: MapCellRec; N: Integer): MapCellRec; + begin + // if mcr.Bounds <> $FF then + if mcr.Bounds and $40 = 0 then + Result := mcr + else + Result := Seq.aMaps[mcr.MapCode].Map[0][N]; + end; + + var + i, j, k, l, m, n, o, p, q: Integer; + a: Integer; + ai: array[0..7] of Integer; + begin + Result := -1; + for i := 0 to GetCount (aMCR[0]) - 1 do + begin + ai[0] := FindMCR (GetMCR (aMCR[0], i)); + for j := 0 to GetCount (aMCR[1]) - 1 do + begin + ai[1] := FindMCR (GetMCR (aMCR[1], j)); + for k := 0 to GetCount (aMCR[2]) - 1 do + begin + ai[2] := FindMCR (GetMCR (aMCR[2], k)); + for l := 0 to GetCount (aMCR[3]) - 1 do + begin + ai[3] := FindMCR (GetMCR (aMCR[3], l)); + for m := 0 to GetCount (mcr) - 1 do + begin + a := FindMCR (GetMCR (mcr, m)); + for n := 0 to GetCount (aMCR[4]) - 1 do + begin + ai[4] := FindMCR (GetMCR (aMCR[4], n)); + for o := 0 to GetCount (aMCR[5]) - 1 do + begin + ai[5] := FindMCR (GetMCR (aMCR[5], o)); + for p := 0 to GetCount (aMCR[6]) - 1 do + begin + ai[6] := FindMCR (GetMCR (aMCR[6], p)); + for q := 0 to GetCount (aMCR[7]) - 1 do + begin + ai[7] := FindMCR (GetMCR (aMCR[7], q)); + Result := AddTileCombination (a, ai); + end; + end; + end; + end; + end; + end; + end; + end; + end; + end; + + begin + H := Length (aaMaps); + for j := 0 to H - 1 do + begin + W := Length (aaMaps[j]); + for i := 0 to W - 1 do + begin + + for edge := 0 to 7 do + begin + X := (i + EdgesX[edge] + W) mod W; + Y := (j + EdgesY[edge] + H) mod H; + aMCR[edge] := aaMaps[Y, X]; + end; + + aaMaps[j, i].Tag := AddAllCombinations (aaMaps[j, i]); + end; + end; + end; + + + + procedure SetEdgeRects (W, H: Integer); + begin + EdgeSrc[0] := MakeRect (W, H, 1, 1); + EdgeSrc[1] := MakeRect (1, H, W, 1); + EdgeSrc[2] := MakeRect (1, H, 1, 1); + EdgeSrc[3] := MakeRect (W, 1, 1, H); + EdgeSrc[4] := MakeRect (1, 1, 1, H); + EdgeSrc[5] := MakeRect (W, 1, 1, 1); + EdgeSrc[6] := MakeRect (1, 1, W, 1); + EdgeSrc[7] := MakeRect (1, 1, 1, 1); + + EdgeDst[0] := MakeRect (0, 0, 1, 1); + EdgeDst[1] := MakeRect (1, 0, W, 1); + EdgeDst[2] := MakeRect (W + 1, 0, 1, 1); + EdgeDst[3] := MakeRect (0, 1, 1, H); + EdgeDst[4] := MakeRect (W + 1, 1, 1, H); + EdgeDst[5] := MakeRect (0, H + 1, 1, 1); + EdgeDst[6] := MakeRect (1, H + 1, W, 1); + EdgeDst[7] := MakeRect (W + 1, H + 1, 1, 1); + + TileCornerX[0] := 0; + TileCornerY[0] := 0; + TileCornerX[1] := W; + TileCornerY[1] := 0; + TileCornerX[2] := 0; + TileCornerY[2] := H; + TileCornerX[3] := W; + TileCornerY[3] := H; + end; + + + procedure GetEdgeColors; + var + i, j, k, x, y: Integer; + begin + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + begin + + for j := 0 to 3 do + begin + with EdgeSrc[CornerToEdge[j]] do + begin + x := Left; + y := Top; + end; + + with TileTab[itab].tbr do + begin + k := (Tiles[j] - 1) * (H + 2); + if k < 0 then + Colors[j] := TRANS_COLOR + else + Colors[j] := bmpTexTiles[itab].Canvas.Pixels[x, y + k]; + end; + end; + + end; + end; + + + function GetBestCorner (tile, corner: Integer; ai: array of Integer): Integer; + var + i, j, N, Total: Integer; + othercorner: Integer; + Diff: Boolean; + begin + N := -1; + othercorner := 3 - corner; + Total := -1; + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if tile = Tiles[corner] then + begin + Diff := FALSE; + for j := 0 to 3 do + if j <> othercorner then + if Colors[j] <> ai[j] then + Diff := TRUE; + if not Diff then + begin + if Count > Total then + begin + N := i; + Total := Count; + end; + end; + end; + + Result := N; + end; + + + function NumberCornerData: Integer; + + function Cmp (N1, N2: Integer): Boolean; + var + i: Integer; + begin + Cmp := TRUE; + for i := 0 to 3 do + if (Corners[itab][N1].Tiles[i] < Corners[itab][N2].Tiles[i]) then + begin + Cmp := FALSE; + Exit; + end + else + if (Corners[itab][N1].Tiles[i] > Corners[itab][N2].Tiles[i]) then + begin + Cmp := TRUE; + Exit; + end; + end; + + var + i, j, k: Integer; + N: Integer; + ai: array of Integer; + begin + N := 0; + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if Used then + begin + Inc (N); + SetLength (ai, N); + ai[N - 1] := i; + end + else + Number := -1; + + for i := 0 to N - 1 do + for j := i + 1 to N - 1 do + if Cmp (ai[i], ai[j]) then + begin + k := ai[i]; + ai[i] := ai[j]; + ai[j] := k; + end; + + for i := 0 to N - 1 do + Corners[itab][ai[i]].Number := i; + + SetLength (ai, 0); + + Result := N; + end; + + + procedure CreateCornerData (tile, edge, N: Integer; ai: array of Integer); + var + i, j, k, l, tc: Integer; + corner: Integer; + Found: Boolean; + Diff: Boolean; + begin + corner := EdgeToCorner[edge]; + + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if Tiles[corner] = tile then + begin + TC := 0; + Diff := FALSE; + for j := 0 to 3 do + begin + if Colors[j] <> ai[j] then + Diff := TRUE; + if Colors[j] = TRANS_COLOR then + Inc (TC); + end; + + if (TC < 4) and Diff then + begin + Found := FALSE; + k := i; + l := Length (aMCRSur[itab][tile][edge]); + for j := 0 to l - 1 do + if j mod 2 = 0 then + if aMCRSur[itab][tile][edge][j] = k then + begin + Inc (aMCRSur[itab][tile][edge][j + 1], Count); + Found := TRUE; + end; + if not Found then + begin + SetLength (aMCRSur[itab][tile][edge], l + 2); + aMCRSur[itab][tile][edge][l] := k; + aMCRSur[itab][tile][edge][l + 1] := Count; + end; + Used := TRUE; + end; + end; + end; + + + procedure CreateHVEdgeData; + + procedure AddHEdge (tile1, tile2, Cnt: Integer); + var + i, L: Integer; + begin + L := Length (HEdges[itab]); + for i := 0 to L - 1 do + with HEdges[itab][i] do + if (Tiles[0] = tile1) and (Tiles[1] = tile2) then + begin + Inc (Count, Cnt); + Exit; + end; + SetLength (HEdges[itab], L + 1); + with HEdges[itab][L] do + begin + Tiles[0] := tile1; + Tiles[1] := tile2; + Count := Cnt; + end; + aHEdgeCount[itab] := L + 1; + end; + + procedure AddVEdge (tile1, tile2, Cnt: Integer); + var + i, L: Integer; + begin + L := Length (VEdges[itab]); + for i := 0 to L - 1 do + with VEdges[itab][i] do + if (Tiles[0] = tile1) and (Tiles[1] = tile2) then + begin + Inc (Count, Cnt); + Exit; + end; + SetLength (VEdges[itab], L + 1); + with VEdges[itab][L] do + begin + Tiles[0] := tile1; + Tiles[1] := tile2; + Count := Cnt; + end; + aVEdgeCount[itab] := L + 1; + end; + + var + tile, edge, L, i: Integer; + begin + for tile := 0 to Length (aMCRSur[itab]) - 1 do + begin + edge := 6; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddHEdge (tile, aMCRSur[itab][tile][edge][i], aMCRSur[itab][tile][edge][i + 1]); + edge := 1; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddHEdge (aMCRSur[itab][tile][edge][i], tile, aMCRSur[itab][tile][edge][i + 1]); + + edge := 4; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddVEdge (tile, aMCRSur[itab][tile][edge][i], aMCRSur[itab][tile][edge][i + 1]); + edge := 3; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + AddVEdge (aMCRSur[itab][tile][edge][i], tile, aMCRSur[itab][tile][edge][i + 1]); + end; + end; + + + procedure SortMCRSur; + var + tile, edge, L, i, j, t1, t2, n1, n2: Integer; + begin + for tile := 0 to Length (aMCRSur[itab]) - 1 do + for edge := 0 to 7 do + begin + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + for j := i + 2 to L - 1 do + if j mod 2 = 0 then + begin + t1 := aMCRSur[itab][tile][edge][i]; + t2 := aMCRSur[itab][tile][edge][j]; + n1 := aMCRSur[itab][tile][edge][i + 1]; + n2 := aMCRSur[itab][tile][edge][j + 1]; + if n1 < n2 then + begin + aMCRSur[itab][tile][edge][i] := t2; + aMCRSur[itab][tile][edge][j] := t1; + aMCRSur[itab][tile][edge][i + 1] := n2; + aMCRSur[itab][tile][edge][j + 1] := n1; + end; + end; + end; + end; + + + function GetMostSurTile (itab, tile, edge: Integer): Integer; + + procedure RemoveMCRSur (P: Integer); + var + i, L: Integer; + begin + L := Length (aMCRSur[itab][tile][edge]); + for i := P to L - 2 - 1 do + aMCRSur[itab][tile][edge][i] := aMCRSur[itab][tile][edge][i + 2]; + SetLength (aMCRSur[itab][tile][edge], L - 2); + end; + + var + i, j, k, L, M, N, C: Integer; + TT, TransTile, TC, TransCount: Integer; + begin { GetMostSurTile } + M := -1; + N := -1; + TransTile := -1; + TransCount := 0; + L := Length (aMCRSur[itab][tile][edge]); + for i := 0 to L - 1 do + if i mod 2 = 0 then + begin + C := aMCRSur[itab][tile][edge][i + 1]; + + TT := aMCRSur[itab][tile][edge][i]; + TC := aTrans[itab][TT][edge]; + if TC > TransCount then + begin + TransCount := TC; + TransTile := TT; + end; + + k := aSameAs[itab][aMCRSur[itab][tile][edge][i]][7 - edge]; + while k > -1 do + begin + for j := 0 to L - 1 do + if j mod 2 = 0 then + if aMCRSur[itab][tile][edge][j] = k then + Inc (C, aMCRSur[itab][tile][edge][j + 1]); + k := aSameAs[itab][k][7 - edge]; + end; + + if C > N then + begin + N := C; + M := aMCRSur[itab][tile][edge][i]; + end; + end; + + if TransCount = 0 then + begin + k := M; + while k > -1 do + begin + for j := Length (aMCRSur[itab][tile][edge]) - 1 downto 0 do + if j mod 2 = 0 then + if aMCRSur[itab][tile][edge][j] = k then + RemoveMCRSur (j); + k := aSameAs[itab][k][7 - edge]; + end; + Result := M; + end + else + Result := TransTile; + end; + + + function RunCode: string; + var + CurPos: Integer; + ErrorPos: Integer; + ErrorMsg: string; + + WritingFile: Boolean; + WritingBinFile: Boolean; // 2.5 + DefaultBinFileBits: Integer; + + ReadingTextFile: Boolean; // 3.0 + ReadingBinFile: Boolean; + InputFileName: string; + InputFilePos: LongInt; + TI: TextFile; + FI: file of Byte; + + + + procedure CodeError (P: Integer; Msg: string); + var + i, Line: Integer; + S: string; + begin + if not Error then + begin + Line := 0; + i := 1; + S := ''; + while i < P do + begin + if i <= Length (code) then + begin + if code[i] = #0 then + begin + S := ''; + Inc (Line); + end + else + S := S + code[i]; + Inc (i); + end; + end; + while (i <= Length (code)) and (code[i] <> #0) do + begin + S := S + code[i]; + Inc (i); + end; + Error := TRUE; + ErrorMsg := 'Error in line ' + IntToStr (Line) + ':'#13#10 + + S + #13#10 + + Msg; + ErrorPos := P; + end; + end; + + function GetToken: string; + var + s: string; + begin + Quote := FALSE; + GetToken := ''; + if CurPos > Length (code) then + Exit + else + begin + s := ''; + if code[CurPos] in ['a'..'z', 'A'..'Z', '0'..'9'] then + repeat + s := s + code[CurPos]; + Inc (CurPos); + until not (code[CurPos] in ['a'..'z', 'A'..'Z', '0'..'9']) + else + begin + s := code[CurPos]; + Inc (CurPos); + if s = '\' then + begin + Quote := TRUE; + s := code[CurPos]; + Inc (CurPos); + if s = 'n' then + s := #13#10; + if s = 'b' then + s := #8; + if s = 't' then + s := #9; + // if s = '0' then // 2.0 + // s := #0; // #0: eof + end; + end; + GetToken := s; + end; + end; + + function LookAheadToken: string; + var + oldpos: Integer; + begin + oldpos := CurPos; + ReadingAhead := TRUE; + LookAheadToken := GetToken; + ReadingAhead := FALSE; + CurPos := oldpos; + end; + + function GetLine: string; + var + t, s: string; + begin + t := ''; + repeat + s := LookAheadToken; + if s <> #0 then + t := t + GetToken; + until (s = '') or (s = #0); + GetLine := t; + end; + + function UGetToken: string; + begin + UGetToken := UpCaseStr (GetToken); + end; + + function USGetToken: string; + var + s: string; + begin + repeat + s := UpCaseStr (GetToken); + until s <> ' '; + USGetToken := s; + end; + + procedure FindEnd (Token: string); + var + s: string; + P: Integer; + RecursiveCount: Integer; + label + again; + begin + P := CurPos; + RecursiveCount := 0; + again: + repeat + s := GetToken; + until ((s = #0) and (LookAheadToken = '#')) or + (s = ''); + if s = '' then + begin + CodeError (P, 'No matching #END ' + Token + ' found'); + Exit; + end; + s := GetToken; // '#' + s := UGetToken; + if s = Token then + begin + Inc (RecursiveCount); + goto again; + end; + if s <> 'END' then + goto again; + if USGetToken <> Token then + goto again; + if RecursiveCount > 0 then + begin + Dec (RecursiveCount); + goto again; + end; + end; + + function GetString: string; + var + s, t: string; + P: Integer; + begin + t := ''; + while LookAheadToken = ' ' do + s := GetToken; + s := GetToken; + if s = #0 then + begin + GetString := ''; + Dec (CurPos); + Exit; + end; + if s = '"' then + begin + P := CurPos; + while LookAheadToken <> '"' do + begin + s := GetToken; + t := t + s; + if s = '' then + begin + CodeError (P, 'Unterminated string'); + Exit; + end; + end; + s := GetToken; + end + else // allow '...' as well as "..." + if s = #39 then + begin + P := CurPos; + while LookAheadToken <> #39 do + begin + s := GetToken; + t := t + s; + if s = '' then + begin + CodeError (P, 'Unterminated string'); + Exit; + end; + end; + s := GetToken; + end + else + begin + repeat + t := t + s; + s := GetToken; + until (s = ' ') or (s = #0) or (s = ''); + if s <> '' then + Dec (CurPos); + end; + GetString := t; + end; + + + function GetTokenSpecial: string; + var + s, t, u, v, fmt: string; + oldpos, erp: Integer; + Number: Integer; + NumberBytes: packed array[0..3] of Byte absolute Number; + F: ShortString; + i, bits: Integer; + begin + if WritingBinFile and (not Quote) and (LookAheadToken = '"') then // 2.5 + begin + GetTokenSpecial := GetString; + Exit; + end + else + t := GetToken; + + if (t = '<') and (not Quote) then + begin + NumericExpr := TRUE; + + oldpos := CurPos; + t := ''; + repeat + s := GetToken; + if (ValidNumber (s)) or + ((Length (s) = 1) and (s[1] in ExprChars)) then + t := t + s + else + t := t + GetVarValue (s, '%d'); + u := LookAheadToken; + until (u = ':') or (u = '>') or (u = #0); + u := GetToken; + + if u = ':' then + begin + fmt := GetString; + u := GetToken; + end + else + if WritingBinFile then + fmt := IntToStr (DefaultBinFileBits) + else + fmt := '%d'; + + if (s = '<') or (u <> '>') then + begin + CurPos := oldpos; + if s = '<' then + t := GetToken; + GetTokenSpecial := t; + Exit; + end; + + if NumericExpr then + begin + F := t; + if not Evaluate (Number, F, Erp) then + Error := TRUE + else + begin + + if WritingBinFile then + begin + bits := -1; + if (ValidNumber (Fmt)) then + bits := StrToInt (Fmt); + + if bits = -1 then + Error := TRUE + else + begin + if bits < 0 then // 2.52 - big endian + begin + bits := Abs (bits); + asm + push ebx + mov eax, Number + mov ecx, bits + mov ebx, 0 + @@1: + shr eax, 1 + rcl ebx, 1 + dec ecx + jnz @@1 + + mov Number, ebx + pop ebx + end; + end; + + v := ''; + for i := 0 to bits div 8 - 1 do + v := v + Chr (NumberBytes[i]); + GetTokenSpecial := #0 + v + #0; + end; + + end + else + begin + v := Format (Fmt, [Number]); + GetTokenSpecial := AddLeadingZeros (v, Fmt); + end; + + end; + end + else + GetTokenSpecial := t; + + if Error then + begin + Error := FALSE; + if NumericExpr then + CodeError (oldpos, 'Error in expression (' + t + ').') + else + CodeError (oldpos, 'Unknown variable (' + t + ').'); + end; + + end + else + GetTokenSpecial := t; + end; + + + function GetStringOrToken: string; + begin + Result := GetString; + exit; + + while LookAheadToken = ' ' do + GetToken; + if LookAheadToken = #0 then + GetStringOrToken := '' + else + if (not WritingBinFile) or (LookAheadToken = '"') then + GetStringOrToken := GetString + else + GetStringOrToken := GetTokenSpecial; + end; + + + function GetFilename: string; + var + s, t: string; + begin + repeat + s := GetTokenSpecial; + until s <> ' '; + t := s; + while (s <> '') and (s <> ' ') and (s <> #0) do + begin + s := GetTokenSpecial; + t := t + s; + end; + if s <> '' then + begin + Dec (CurPos); + if t <> '' then + Delete (t, Length (t), 1); // bug fix 2.5 (saving .PNG files) + end; + + if (t[1] in ['"', #39]) and (t[Length (t)] = t[1]) then + t := Copy (t, 2, Length (t) - 2); + + GetFilename := t; + end; + + + function AdjustFilename (Filename: string; Path: string): string; + begin + if (Filename = '') or (Pos (':', Filename) = 2) or (Filename[1] = '\') then + AdjustFilename := Filename + else + AdjustFilename := Path + Filename; + end; + + + function GetTextFileLineCount (Filename: string): LongInt; + var + TF: TextFile; + N: LongInt; + begin + if not FileExists (Filename) then + begin + GetTextFileLineCount := 0; + Exit; + end; + AssignFile (TF, Filename); + N := 0; + Reset (TF); + while not Eof (TF) do + begin + ReadLn (TF); + Inc (N); + end; + CloseFile (TF); + GetTextFileLineCount := N; + end; + + function GetBinFileSize (Filename: string): LongInt; + var + F: file of Byte; + begin + AssignFile (F, Filename); + Reset (F); + GetBinFileSize := FileSize (F); + CloseFile (F); + end; + + + function GetValidTileSet: Boolean; + begin + GetValidTileSet := TRUE; + while itab < Tab.Tabs.Count do + with TileTab[itab] do + begin + if not TileTab[itab].tbr.SkipExport then // 2.2 + begin + ValidTileSet := TRUE; + ValidTSTileSet := TRUE; + if (bmpFinal[itab].Height > 0) then + Exit; + ValidTileSet := FALSE; + if (tbr.TileCount > 0) then + Exit; + ValidTSTileSet := FALSE; + end; + Inc (itab); + end; + ValidTileSet := FALSE; + ValidTSTileSet := FALSE; + GetValidTileSet := FALSE; + end; + + + // 2.4 + function InitCornerVars: Boolean; // false if no more corners + var + i: Integer; + begin + InitCornerVars := FALSE; + SetNumVar ('CornerNumber', -1); + if TexTiles then + begin + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if icorner = Number then + begin + SetNumVar ('TopLeftTile', Tiles[0]); + SetNumVar ('TopRightTile', Tiles[1]); + SetNumVar ('BottomLeftTile', Tiles[2]); + SetNumVar ('BottomRightTile', Tiles[3]); + { + SetNumVar ('TopLeftColor', Colors[0]); + SetNumVar ('TopRightColor', Colors[1]); + SetNumVar ('BottomLeftColor', Colors[2]); + SetNumVar ('BottomRightColor', Colors[3]); + } + SetNumVar ('CornerNumber', icorner); + InitCornerVars := TRUE; + end; + end; + end; + + procedure InitHEdgeVars; + begin + SetNumVar ('HEdgeNumber', ihedge); + with HEdges[itab][ihedge] do + begin + SetNumVar ('TopTile', Tiles[0]); + SetNumVar ('BottomTile', Tiles[1]); + end; + end; + + procedure InitVEdgeVars; + begin + SetNumVar ('VEdgeNumber', ivedge); + with VEdges[itab][ivedge] do + begin + SetNumVar ('LeftTile', Tiles[0]); + SetNumVar ('RightTile', Tiles[1]); + end; + end; + + + + procedure InitPaletteVars; + var + s: string; + begin + SetNumVar ('PaletteNumber', ipal); + s := PaletteManager.GetID (ipal); + SetStrVar ('PaletteIdentifier', s); + if s = '' then + begin + SetNumVar ('PaletteSize', 0); + SetNumVar ('PalettePreset', 0); + end + else + begin + SetNumVar ('PaletteSize', aiPalSize[ipal]); + SetNumVar ('PalettePreset', aiPreset[ipal]); + end; + end; + + procedure InitTileSetVars; + var + R, G, B: Integer; + NH, NV: Integer; + N, MC: Integer; + begin + with TileTab[itab] do + begin + GetRGB (TRANS_COLOR, R, G, B); + NH := bmpFinal[itab].Width div tbr.W; + NV := bmpFinal[itab].Height div tbr.H; + + SetStrVar ('TileSetIdentifier', tab.Tabs[itab]); + SetNumVar ('TileSetNumber', itab); + SetNumVar ('TileWidth', tbr.W div GetTinyNH); + SetNumVar ('TileHeight', tbr.H div GetTinyNV); + + // SetNumVar ('TileCount', NH * NV); + if TinyTiles then + begin + SetNumVar ('TileCount', aFinalTinyTileCount[itab][NOFLIP]); + SetNumVar ('TSTileCount', tbr.TileCount * TinyNH * TinyNV); // 2.2 + end + else + begin + SetNumVar ('TileCount', aFinalTileCount[itab]); // 2.0 + SetNumVar ('TSTileCount', tbr.TileCount); // 2.2 + + if UTT then + SetNumVar ('UniqueTexTileCount', aUTTCount[itab]); // 2.5 + end; + + SetNumVar ('SequenceCount', 0); // 2.52 + SetNumVar ('MapCount', 0); // 2.53 + + if ValidTileSet then + begin + SetNumVar ('HorizontalTileCount', NH); + SetNumVar ('VerticalTileCount', NV); + SetNumVar ('TileSetBitmapWidth', bmpFinal[itab].Width); + SetNumVar ('TileSetBitmapHeight', bmpFinal[itab].Height); + SetNumVar ('TransparentPosX', TransX[itab]); // 2.0 update documentation! + SetNumVar ('TransparentPosY', TransY[itab]); + + // SetNumVar ('MapCount', Length (tbr.Maps.aMaps)); + MC := 0; + for N := 0 to Length (tbr.Maps.aMaps) - 1 do // 2.53: fixed: MapCount doesn't include skipped maps + if not tbr.Maps.aMaps[N].SkipExport then Inc (MC); // 2.55: fixed MapCount + SetNumVar ('MapCount', MC); + + SetNumVar ('SequenceCount', Length (tbr.Seq.aMaps)); + end + else // 3.0 + if (tbr.LastExportW <> 0) and (tbr.LastExportH <> 0) then + begin + SetNumVar ('HorizontalTileCount', tbr.LastExportW div tbr.W); + SetNumVar ('VerticalTileCount', tbr.LastExportH div tbr.H); + SetNumVar ('TileSetBitmapWidth', tbr.LastExportW); + SetNumVar ('TileSetBitmapHeight', tbr.LastExportH); + SetNumVar ('TransparentPosX', tbr.LastExportTransX); + SetNumVar ('TransparentPosY', tbr.LastExportTransY); + end; + + SetNumVar ('TransparentColorR', R); + SetNumVar ('TransparentColorG', G); + SetNumVar ('TransparentColorB', B); + GetRGB (BackGrColor, R, G, B); + SetNumVar ('BackgroundColorR', R); + SetNumVar ('BackgroundColorG', G); + SetNumVar ('BackgroundColorB', B); + + SetNumVar ('Overlap', tbr.Overlap); // 2.0 + + // 2.0 + // if ipal = -1 then // bug fix 2.34 (caused all tile sets to use first palette) + begin + ipal := tbr.PaletteNumber; + InitPaletteVars; + end; + + // 2.4 + if TexTiles then + begin + SetNumVar ('CornerCount', aCornerCount[itab]); + SetNumVar ('HEdgeCount', aHEdgeCount[itab]); + SetNumVar ('VEdgeCount', aVEdgeCount[itab]); + end; + + SetEdgeRects (tbr.W, tbr.H); // 2.5 + end; + end; + + + procedure InitTileVars (Tile0: Boolean); + + procedure InitSurVar (VarName: string; Edge: Integer); + var + it: Integer; + begin + if Tile0 then + it := 0 + else + it := itile + 1; + SetNumVar (VarName, 0); + if TexTiles and (iutt < 0) then + if it < Length (aMCRSur[itab]) then + SetNumVar (VarName, Integer (Boolean (Length (aMCRSur[itab][it][Edge]) <> 0))) + end; + + begin { InitTileVars } + + if tile0 then + SetNumVar ('TileNumber', -1) + else + if iutt >= 0 then + SetNumVar ('TileNumber', iutt) + else + if itstile >= 0 then + SetNumVar ('TileNumber', itstile) + else + SetNumVar ('TileNumber', itile); + + // 2.4 + InitSurVar ('OtherTopLeftCorners', 0); + InitSurVar ('OtherTopEdges', 1); + InitSurVar ('OtherTopRightCorners', 2); + InitSurVar ('OtherLeftEdges', 3); + InitSurVar ('OtherRightEdges', 4); + InitSurVar ('OtherBottomLeftCorners', 5); + InitSurVar ('OtherBottomEdges', 6); + InitSurVar ('OtherBottomRightCorners', 7); + + // 2.5 + if TexTiles then + begin + SetNumVar ('UniqueTexTileNumber', iutt); + end; + end; + + + // 2.4 + procedure InitPixelVars (RGB: Integer; A: Integer); + var + i, R, G, B: Integer; + rr, gg, bb, index, tmp, best: Integer; + begin + GetRGB (RGB, R, G, B); + SetNumVar ('RGB', RGB); + + SetNumVar ('R', R); + SetNumVar ('G', G); + SetNumVar ('B', B); + + if A > 255 then A := 255 else if A < 0 then A := 0; + SetNumVar ('A', A); + + SetNumVar ('Pixel', 0); + + if (ipal >= 0) and (Length (aaiPal) > 0) then + if Length (aaiPal[ipal]) > 0 then + begin + best := -1; + index := -1; + + for i := 0 to { Length (aaiPal[ipal]) } aiPalSize[ipal] - 1 do // 2.41 + begin + GetRGB (aaiPal[ipal][i], rr, gg, bb); + tmp := sqr ((R - rr) * 2) + sqr ((G - gg) * 2) + sqr ((B - bb) * 2); + if (index = -1) or (tmp < best) then + begin + index := i; + best := tmp; + end; + end; + SetNumVar ('Pixel', index); + end; + + if RGB = TRANS_COLOR then + begin + SetNumVar ('Pixel', -1); + SetNumVar ('A', 0); + end; + + CurRGB := RGB; // 2.54 + end; + + + function InitHEdgeDatVars: Boolean; + var + i, j: Integer; + RGB: Integer; + A: Integer; + begin + with TileTab[itab] do + begin + with HEdges[itab][ihedge] do + begin + i := 1 + (ihedgedat mod tbr.W); + if ihedgedat div tbr.W = 0 then + j := (Tiles[0] - 1) * (tbr.H + 2) + tbr.H + else + j := (Tiles[1] - 1) * (tbr.H + 2) + 1; + + if j < 0 then + RGB := TRANS_COLOR + else + RGB := bmpTexTiles[itab].Canvas.Pixels[i, j]; + + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[i, j]; + InitPixelVars (RGB, A); + + SetNumVar ('X', ihedgedat mod tbr.W); + SetNumVar ('Y', ihedgedat div tbr.W); + end; + end; + InitHEdgeDatVars := RGB <> TRANS_COLOR; + end; + + + function InitVEdgeDatVars: Boolean; + var + i, j: Integer; + RGB: Integer; + A: Integer; + begin + with TileTab[itab] do + begin + with VEdges[itab][ivedge] do + begin + if ivedgedat mod 2 = 0 then + i := tbr.W + else + i := 1; + j := (Tiles[ivedgedat mod 2] - 1) * (tbr.H + 2) + (ivedgedat div 2) + 1; + if j < 0 then + RGB := TRANS_COLOR + else + RGB := bmpTexTiles[itab].Canvas.Pixels[i, j]; + + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[i, j]; + InitPixelVars (RGB, A); + + SetNumVar ('X', ivedgedat mod 2); + SetNumVar ('Y', ivedgedat div 2); + end; + end; + InitVEdgeDatVars := RGB <> TRANS_COLOR; + end; + + + function InitCornerDatVars: Boolean; + var + i: Integer; + RGB: Integer; + begin + RGB := TRANS_COLOR; + { SetNumVar ('CornerNumber', -1); } + for i := 0 to Length (Corners[itab]) - 1 do + with Corners[itab][i] do + if icorner = Number then + begin + RGB := Colors[icornerdat]; + InitPixelVars (RGB, 255); + { SetNumVar ('Index', icornerdat); } + SetNumVar ('X', icornerdat mod 2); + SetNumVar ('Y', icornerdat div 2); + end; + InitCornerDatVars := RGB <> TRANS_COLOR; + end; + + + + { + procedure InitTinyTileVars; + begin + SetNumVar ('TinyTileNumber', itinytile); + end; + } + + { + function InitTinyTileDatVars: Boolean; + var + x, y: Integer; + i, RGB, R, G, B: Integer; + rr, gg, bb, index, tmp, best: Integer; + begin + with TileTab[itab] do + begin + GetTinyPos (itab, aFinalTinyTiles[itab][TinyFlip][itinytile], x, y); + Inc (x, idat mod TinyW); + Inc (y, idat div TinyH); + + RGB := bmpFinal[itab].Canvas.Pixels[x, y]; + + InitPixelVars (RGB, 255); + end; + InitTinyTileDatVars := RGB <> TRANS_COLOR; + end; + } + + // returns FALSE if pixel is transparent + function InitTileDatVars: Boolean; + var + NH, x, y: Integer; + tbrtilenr, tinytilenr: Integer; + RGB: Integer; + xpos, ypos: Integer; // 2.34 + A: Integer; // 2.5 + i, j, k: Integer; + rr, gg, bb: Integer; + tr, tg, tb, ta: Integer; + begin + with TileTab[itab] do + begin + if itstile >= 0 then + begin + if TinyTiles then + begin + + // if 4 * itstile div (TinyNH * TinyNV) > 0 then + // asm nop end; + + tbrtilenr := itstile div (TinyNH * TinyNV); + tinytilenr := itstile mod (TinyNH * TinyNV); + x := tbr.w * tbrtilenr; + y := 0; + Inc (x, (tinytilenr mod TinyNH) * TinyW); + Inc (y, (tinytilenr div TinyNH) * TinyH); + { + x := tbr.W * itstile div (TinyNH * TinyNV) + + TinyW * ((itstile mod (TinyNH * TinyNV)) mod TinyNH); + y := TinyH * ((itstile mod (TinyNH * TinyNV)) div TinyNH); + } + XPos := idat mod TinyW; + YPos := idat div TinyW; + end + else + begin { not tinytiles } + x := tbr.W * itstile; + y := 0; + XPos := idat mod tbr.W; + YPos := idat div tbr.W; + end; + + if aa then + begin + tr := 0; tg := 0; tb := 0; ta := 0; + k := 0; + + for j := 0 to aaY - 1 do + for i := 0 to aaX - 1 do + begin + RGB := tbr.TileBitmap.Canvas.Pixels[x * aaX + XPos * aaX + i, y * aaY + YPos * aaY + j]; + if RGB <> TRANS_COLOR then + begin + GetRGB (RGB, rr, gg, bb); + Inc (tr, rr); + Inc (tg, gg); + Inc (tb, bb); + Inc (ta, 255); + Inc (k); + end; + end; + if ta = 0 then + begin + RGB := TRANS_COLOR; + A := 0; + end + else + begin + RGB := (tr div k) + ((tg div k) shl 8) + ((tb div k) shl 16); + A := ta div (aaX * aaY); + end; + + end + else + begin + RGB := tbr.TileBitmap.Canvas.Pixels[x + XPos, y + YPos]; + A := 255; + end; + + end + else + begin { itstile = -1 } + + if TinyTiles then + begin + GetTinyPos (itab, aFinalTinyTiles[itab][TinyFlip][itile], x, y); + XPos := idat mod TinyW; + YPos := idat div TinyW; + if (x = -1) or (y = -1) then + begin + RGB := TRANS_COLOR; + A := 0; + end + else + begin + Inc (x, XPos); + Inc (y, YPos); + RGB := bmpFinal[itab].Canvas.Pixels[x, y]; + if aa then + A := bmpAlpha[itab].Canvas.Pixels[x, y] + else + A := 255; + end; + end + else + begin { not TinyTiles } + NH := bmpFinal[itab].Width div tbr.W; + x := (itile mod NH) * tbr.W; + y := (itile div NH) * tbr.H; + XPos := idat mod tbr.W; + YPos := idat div tbr.W; + Inc (x, XPos); + Inc (y, YPos); + RGB := bmpFinal[itab].Canvas.Pixels[x, y]; + if aa then + A := bmpAlpha[itab].Canvas.Pixels[x, y] + else + A := 255; + end; + + end; + + InitPixelVars (RGB, A); + + // 2.34 + SetNumVar ('X', XPos); + SetNumVar ('Y', YPos); + + end; + InitTileDatVars := RGB <> TRANS_COLOR; + end; + + + + // 2.4 + function InitTexTileDatVars: Boolean; // FALSE: transparent + var + NH, x, y: Integer; + xpos, ypos: Integer; + RGB: Integer; + t, tile, j, k, l, edge: Integer; + tmpx, tmpy: Integer; + A: Integer; + + function Inside (X, Y: Integer; R: TRect): Boolean; + begin + Inside := (X >= R.Left) and (X < R.Right) and + (Y >= R.Top) and (Y < R.Bottom); + end; + + begin + with TileTab[itab] do + begin + NH := bmpTexTiles[itab].Width div (tbr.W + 2); + + if UTT and (iutt >= 0) then + begin + t := aUTTIndex[itab][iutt] - 1; + tile := t; + XPos := idat mod (tbr.W + 2); + YPos := (idat div (tbr.W + 2)) mod (tbr.H + 2); + tmpx := XPos; + tmpy := YPos; + + { + tmpx := XPos - EdgeDst[edge].Left + EdgeSrc[7 - edge].Left; + tmpy := YPos - EdgeDst[edge].Top + EdgeSrc[7 - edge].Top; + } + + for edge := 0 to 7 do + if Inside (XPos, YPos, EdgeDst[edge]) then + if (t + 1 < Length (aUTTRef[itab])) then + begin + + l := Length (aUTTRef[itab][t + 1]); + for j := 0 to l - 1 do + if aUTTRef[itab][t + 1][j][8] = iutt + 1 then + begin + k := aUTTRef[itab][t + 1][j][edge]; + if EdgeToCorner[edge] = -1 then + tile := k - 1 + else + tile := Corners[itab][k].Tiles[EdgeToCorner[7 - edge]] - 1; + tmpx := XPos - EdgeDst[edge].Left + EdgeSrc[edge].Left; + tmpy := YPos - EdgeDst[edge].Top + EdgeSrc[edge].Top; + end; + end; + + if tile = -1 then + begin + RGB := TRANS_COLOR; + A := 0; + end + else + begin + x := (tile mod NH) * (tbr.W + 2); + y := (tile div NH) * (tbr.H + 2); + Inc (x, tmpx); + Inc (y, tmpy); + RGB := bmpTexTiles[itab].Canvas.Pixels[x, y]; + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[x, y]; + end; + + end + else + begin + x := (itile mod NH) * (tbr.W + 2); + y := (itile div NH) * (tbr.H + 2); + XPos := idat mod (tbr.W + 2); + YPos := idat div (tbr.W + 2); + Inc (x, XPos); + Inc (y, YPos); + RGB := bmpTexTiles[itab].Canvas.Pixels[x, y]; + A := 255; + if aa then + A := bmpTexAlpha[itab].Canvas.Pixels[x, y]; + end; + + InitPixelVars (RGB, A); + + SetNumVar ('X', XPos); + SetNumVar ('Y', YPos); + end; + InitTexTileDatVars := RGB <> TRANS_COLOR; + end; + + + procedure InitMapVars; + begin + with TileTab[itab].tbr.Maps.aMaps[imap] do + begin + SetStrVar ('MapIdentifier', ID); + SetNumVar ('MapNumber', imap); + MapHt := Length (Map) * GetTinyNV; + if MapHt = 0 then + MapWd := 0 + else + MapWd := Length (Map[0]) * GetTinyNH; + SetNumVar ('MapHeight', MapHt); + SetNumVar ('MapWidth', MapWd); + SetStrVar ('ScrollX', fx); // 2.0 update documentation! + SetStrVar ('ScrollY', fy); + + end; + end; + + + procedure InitTileMapVars; + var + x, y: Integer; + begin + if not TinyTiles then + Exit; + + x := itilemap mod TinyNH; + y := (itilemap div TinyNH) mod TinyNV; + + SetNumVar ('TinyTileNumber', aFinalTinyRef[itab][itile * 4 + itilemap][NOFLIP]); // ???????? + + SetNumVar ('X', x); + SetNumVar ('Y', y); + end; + + + procedure InitMCRVars (mcr: MapCellRec); + var + TotalOfsX, + TotalOfsY: Integer; // 2.4 + + procedure AddOfs (tile: Integer); + begin + tile := tile and TILE_MASK; + with TileTab[itab].tbr do + begin + if tile < Length (OffsetX) then + Inc (TotalOfsX, OffsetX[tile]); + if tile < Length (OffsetY) then + Inc (TotalOfsY, OffsetY[tile]); + end; + end; + + begin + TotalOfsX := 0; + TotalOfsY := 0; + + // if mcr.Bounds = $FF then + if mcr.Bounds and $40 <> 0 then + begin + // SetNumVar ('TSBackTile', -1); // 2.2 + SetNumVar ('TSBackTile', -(mcr.MapCode + 1)); + SetNumVar ('TSBackTile1', -(mcr.MapCode + 1)); // 2.53 + SetNumVar ('TSBackHF', 0); + SetNumVar ('TSBackVF', 0); + SetNumVar ('TSBackR', 0); + // SetNumVar ('TSMidTile', -1); + SetNumVar ('TSMidTile', -(mcr.MapCode + 1)); + SetNumVar ('TSMidTile1', -(mcr.MapCode + 1)); + SetNumVar ('TSMidHF', 0); + SetNumVar ('TSMidVF', 0); + SetNumVar ('TSMidR', 0); + // SetNumVar ('TSFrontTile', -1); + SetNumVar ('TSFrontTile', -(mcr.MapCode + 1)); + SetNumVar ('TSFrontTile1', -(mcr.MapCode + 1)); + SetNumVar ('TSFrontHF', 0); + SetNumVar ('TSFrontVF', 0); + SetNumVar ('TSFrontR', 0); + end + else + begin + if mcr.Back = -1 then + begin + SetNumVar ('TSBackTile', -1); + SetNumVar ('TSBackTile1', 0); + SetNumVar ('TSBackHF', 0); + SetNumVar ('TSBackVF', 0); + SetNumVar ('TSBackR', 0); + end + else + begin + AddOfs (mcr.Back); + SetNumVar ('TSBackTile', mcr.Back and TILE_MASK); + SetNumVar ('TSBackTile1', (mcr.Back and TILE_MASK) + 1); + SetNumVar ('TSBackHF', Byte (mcr.Back and MIRROR_MASK <> 0)); + SetNumVar ('TSBackVF', Byte (mcr.Back and UPS_MASK <> 0)); + SetNumVar ('TSBackR', Byte (mcr.Back and ROTATE_MASK <> 0)); + end; + + if mcr.Mid = -1 then + begin + SetNumVar ('TSMidTile', -1); + SetNumVar ('TSMidTile1', 0); + SetNumVar ('TSMidVF', 0); + SetNumVar ('TSMidHF', 0); + SetNumVar ('TSMidR', 0); + end + else + begin + AddOfs (mcr.Mid); + SetNumVar ('TSMidTile', mcr.Mid and TILE_MASK); + SetNumVar ('TSMidTile1', (mcr.Mid and TILE_MASK) + 1); + SetNumVar ('TSMidHF', Byte (mcr.Mid and MIRROR_MASK <> 0)); + SetNumVar ('TSMidVF', Byte (mcr.Mid and UPS_MASK <> 0)); + SetNumVar ('TSMidR', Byte (mcr.Mid and ROTATE_MASK <> 0)); + end; + + if mcr.Front = -1 then + begin + SetNumVar ('TSFrontTile', -1); + SetNumVar ('TSFrontTile1', 0); + SetNumVar ('TSFrontHF', 0); + SetNumVar ('TSFrontVF', 0); + SetNumVar ('TSFrontR', 0); + end + else + begin + AddOfs (mcr.Front); + SetNumVar ('TSFrontTile', mcr.Front and TILE_MASK); + SetNumVar ('TSFrontTile1', (mcr.Front and TILE_MASK) + 1); + SetNumVar ('TSFrontHF', Byte (mcr.Front and MIRROR_MASK <> 0)); + SetNumVar ('TSFrontVF', Byte (mcr.Front and UPS_MASK <> 0)); + SetNumVar ('TSFrontR', Byte (mcr.Front and ROTATE_MASK <> 0)); + end; + end; + + SetNumVar ('OffsetX', TotalOfsX); + SetNumVar ('OffsetY', TotalOfsY); + end; + + procedure InitMapDatVars; + var + x, y, i, j: Integer; + mcr: MapCellRec; + begin + with TileTab[itab].tbr.Maps.aMaps[imap] do + begin + y := idat div MapWd; + x := idat mod MapWd; + mcr := Map[y div GetTinyNV, x div GetTinyNH]; + InitMCRVars (mcr); + // if mcr.Bounds = $FF then + if mcr.Bounds and $40 <> 0 then + begin + i := mcr.MapCode; + j := -(i + 1); + // if mcr.Bounds and $7F = 0 then // 2.55 + // mcr.Bounds := TileTab[itab].tbr.Seq.aMaps[i].Map[0, 0].Bounds; + end + else + begin + i := FindMCR (mcr); + j := aFinalRef[itab][i]; + end; + + if TinyTiles then + begin + if j > 0 then + begin + Dec (j); + j := aFinalTinyRef[itab][j * GetTinyNH * GetTinyNV + + (y mod GetTinyNV) * GetTinyNH + + (x mod GetTinyNH)][TinyFlip]; + { j := aFinalTinyTiles[itab][TinyFlip][j] + 1; } + end + else // 2.34 + if j < 0 then + begin + j := (j + 1) * GetTinyNH * GetTinyNV - 1 - + ((y mod GetTinyNV) * GetTinyNH + (x mod GetTinyNH)); + end; + end; { tinytiles } + + // 2.5 + if TexTiles then + begin + if j < 0 then + SetNumVar ('UniqueTexTileNumber', j) + else + SetNumVar ('UniqueTexTileNumber', mcr.Tag); + end; + + SetNumVar ('TileNumber', j); + SetNumVar ('TileNumberLoByte', j mod $100); + SetNumVar ('TileNumberHiByte', j div $100); + with mcr do + begin + if j < 0 then + MapCode := 0; + SetNumVar ('Bounds', Bounds and (not $40)); + SetNumVar ('MapCode', MapCode); + SetNumVar ('BoundMapValue', (Bounds and (not $40)) + (MapCode shl 8)); + end; + + // 2.34 + SetNumVar ('X', x); + SetNumVar ('Y', y); + + end; + end; + + procedure InitSeqVars; + var + m, c: Integer; + i, j, k: Integer; + Count: Integer; + { LastSize: Integer; } + isq: Integer; + nvh: Integer; + // x, y: Integer; + s: string[255]; + begin + nvh := GetTinyNH * GetTinyNV; // 2.34 tinytiles sequences + isq := iseq div nvh; + k := iseq mod nvh; + // x := k mod GetTinyNH; + // y := k div GetTinyNH; + + SeqFrames := 0; + if Length (TileTab[itab].tbr.Seq.aMaps) <= 0 then + SeqLen := 0 + else + with TileTab[itab].tbr.Seq.aMaps[isq] do + begin + if Length (Map) < 1 then + SeqLen := 0 + else + begin + SeqLen := Length (Map[0]); + for i := 0 to SeqLen - 1 do // 3.0 + Inc (SeqFrames, 1 + Map[0][i].MapCode); + end; + + SetStrVar ('SpriteName', tab.Tabs[itab]); + SetNumVar ('SpriteNumber', iseq); + { LastSize := -1; } + with TileTab[itab].tbr.Maps do + for m := 0 to Length (aMaps) - 1 do + with aMaps[m] do + begin + Count := 0; + s := ''; + if Length (Map) > 0 then + { if (LastSize = -1) or + (Length (Map) * Length (Map[0]) <= LastSize) then } + begin + { LastSize := Length (Map) * Length (Map[0]); } + for j := 0 to Length (Map) - 1 do + for i := 0 to Length (Map[j]) - 1 do + // if (Map[j, i].Bounds = $FF) then + if (Map[j, i].Bounds and $40 <> 0) then + begin + c := Map[j, i].MapCode; + // if Pos (Chr (c), s) = 0 then { huh??? } + begin + s := s + Chr (c); + Inc (Count); + + if c = isq then + begin + SetStrVar ('SpriteName', + TileTab[itab].tbr.Maps.aMaps[m].ID); + + if TinyTiles then + SetNumVar ('SpriteNumber', (Count - 1) * nvh + 1 + k) + else + SetNumVar ('SpriteNumber', Count); + end; + end; + end; + end; + end; + + // SetNumVar ('SpriteNumber', iseq); // 2.43 + SetNumVar ('SequenceNumber', iseq + 1); + end; + SetNumVar ('SequenceLength', SeqLen); + SetNumVar ('SpriteLength', SeqLen); + end; + + procedure InitPalDatVars; + var + i, R, G, B: Integer; + begin + i := aaiPal[ipal][ipaldat]; + SetNumVar ('RGB', i); + GetRGB (i, R, G, B); + SetNumVar ('Index', ipaldat); + SetNumVar ('R', R); + SetNumVar ('G', G); + SetNumVar ('B', B); + end; + + procedure InitSeqDatVars; + var + i, j, k: Integer; + mcr: MapCellRec; + isq, nvh: Integer; + // t, x, y: Integer; + begin + nvh := GetTinyNH * GetTinyNV; // 2.34 tinytiles sequences + isq := iseq div nvh; + k := iseq mod nvh; + + with TileTab[itab].tbr.Seq.aMaps[isq] do + begin + mcr := Map[0, iseqdat]; + InitMCRVars (mcr); + i := FindMCR (mcr); + j := aFinalRef[itab][i]; + + if TinyTiles then + if j > 0 then + begin + Dec (j); + j := aFinalTinyRef[itab][j * nvh + k][TinyFlip]; + end; + + SetNumVar ('TileNumber', j); + SetNumVar ('FrameCount', mcr.MapCode); + + // 2.5 + if TexTiles then + SetNumVar ('UniqueTexTileNumber', mcr.Tag); + + // 2.34 + SetNumVar ('Frame', iseqdat); + + + SetNumVar ('TileNumberLoByte', j mod $100); // 2.55 + SetNumVar ('TileNumberHiByte', j div $100); + with mcr do + begin + if j < 0 then + MapCode := 0; + SetNumVar ('Bounds', Bounds and (not $40)); + SetNumVar ('MapCode', MapCode); + SetNumVar ('BoundMapValue', (Bounds and (not $40)) + (MapCode shl 8)); + end; + + + end; + end; + + + procedure InitSeqFrameVars; + var + i, j, k: Integer; + mcr: MapCellRec; + isq, nvh: Integer; + // t, x, y: Integer; + begin + nvh := GetTinyNH * GetTinyNV; // 2.34 tinytiles sequences + isq := iseq div nvh; + k := iseq mod nvh; + + with TileTab[itab].tbr.Seq.aMaps[isq] do + begin + + i := iseqdat; + j := 0; + repeat + mcr := Map[0, j]; + Dec (i, mcr.MapCode + 1); + if i >= 0 then + Inc (j); + until (i < 0) or (j >= Length (Map[0])); + + InitMCRVars (mcr); + i := FindMCR (mcr); + j := aFinalRef[itab][i]; + + if TinyTiles then + if j > 0 then + begin + Dec (j); + j := aFinalTinyRef[itab][j * nvh + k][TinyFlip]; + end; + + SetNumVar ('TileNumber', j); + SetNumVar ('FrameCount', mcr.MapCode); + + // 2.5 + if TexTiles then + SetNumVar ('UniqueTexTileNumber', mcr.Tag); + + // 2.34 + SetNumVar ('Frame', iseqdat); + + + SetNumVar ('TileNumberLoByte', j mod $100); // 2.55 + SetNumVar ('TileNumberHiByte', j div $100); + with mcr do + begin + if j < 0 then + MapCode := 0; + SetNumVar ('Bounds', Bounds and (not $40)); + SetNumVar ('MapCode', MapCode); + SetNumVar ('BoundMapValue', (Bounds and (not $40)) + (MapCode shl 8)); + end; + + + end; + end; + + + procedure GetList (ListName: string; var str: TStringList); + var + i: Integer; + Copying: Boolean; + s, t: string; + lines: TStringList; + begin + str.Clear; + Copying := FALSE; + + // avoid strange bug (delphi 5): Lists.Notes.Lines.Count returns 0 if ListsForm hasn't been shown yet + lines := TStringList.Create(); + lines.Text := Lists.Notes.Lines.Text; + + //for i := 0 to Lists.Notes.Lines.Count - 1 do + for i := 0 to lines.Count - 1 do + begin + //s := Lists.Notes.Lines.Strings[i]; + s := lines.Strings[i]; + t := Trim (s); + if t = '' then + Copying := FALSE + else + if (t[1] = '[') and (t[Length(t)] = ']') then + Copying := FALSE; + if Copying then + str.Add (s); + if Trim (UpCaseStr (s)) = '[' + UpCaseStr (ListName) + ']' then + Copying := TRUE; + end; + end; + + + function GetListLength (ListName: string): Integer; + var + str: TStringList; + begin + str := TStringList.Create (); + GetList (ListName, str); + GetListLength := str.Count; + str.Free; + end; + + + procedure InitListVars (ListName: string; Index: Integer; Depth: Integer); + var + str: TStringList; + s: string; + begin + str := TStringList.Create (); + GetList (ListName, str); + if Index < str.Count then + begin + s := str[Index]; + SetNumVar ('Index', Index); + SetStrVar ('Item', s); + if ValidNumber (s) then SetNumVar ('ItemValue', StrToInt (s)); + SetNumVar (ListName + 'Index', Index); + SetStrVar (ListName + 'Item', s); + if ValidNumber (s) then SetNumVar (ListName + 'ItemValue', StrToInt (s)); + SetNumVar (ListName + 'Index' + IntToStr (Depth), Index); + SetStrVar (ListName + 'Item' + IntToStr (Depth), s); + if ValidNumber (s) then SetNumVar (ListName + 'ItemValue' + IntToStr (Depth), StrToInt (s)); + end; + str.Free; + end; + + + procedure InitFileDatVars; + var + s: string; + b: Byte; + begin + if ReadingTextFile then + begin + ReadLn (TI, s); + SetStrVar ('TextFileLine', s); + if ValidNumber (s) then SetNumVar ('TextFileLineValue', StrToInt (s)); + SetNumVar ('LineNumber', InputFilePos); + end; + if ReadingBinFile then + begin + BlockRead (FI, b, 1); + SetStrVar ('BinFileChar', Chr (b)); + SetNumVar ('BinFileByte', b); + SetNumVar ('BinFilePos', InputFilePos); + end; + Inc (InputFilePos); + end; + + + + // -------------- + + + procedure WidenBitmap (NewWidth: Integer); + var + W, H: Integer; + Wd, M, N: Integer; + x, y, i, j: Integer; + Found: Boolean; + begin + W := TileTab[itab].tbr.W; + H := TileTab[itab].tbr.H; + if (W = 0) or (bmpFinal[itab].Width <> W) then + Exit; + N := 1; + Wd := W; + while Wd + W <= NewWidth do + begin + Inc (Wd, W); + Inc (N); + end; + if N <= 1 then + Exit; + M := bmpFinal[itab].Height div H; + if M > N then + begin + j := (M + (N - 1)) div N; // height + i := j * N - M; // # unused + while i >= j do + begin + Dec (Wd, W); + Dec (N); + Dec (i, j); + end; + end; + with bmpFinal[itab] do + begin + Canvas.Brush.Color := TRANS_COLOR; + Width := Wd; + for i := 0 to M - 1 do + begin + x := (i mod N) * W; + y := (i div N) * H; + Canvas.CopyRect (MakeRect (x, y, W, H), Canvas, MakeRect (0, i * H, W, H)); + end; + Height := ((M + (N - 1)) div N) * H; + if M <= N then + Width := M * W; + + Found := FALSE; + for j := 0 to Height - 1 do + for i := 0 to Width - 1 do + if not Found then + if Canvas.Pixels[i, j] = TRANS_COLOR then + begin + TransX[itab] := i; + TransY[itab] := j; + Found := TRUE; + end; + + // if not Found then .... impossible! + end; + end; + + + type + CmdType = (ctFile, ctBinFile, ctTileSet, ctTile, ctTSTile, ctTinyTiles, + ctTileData, ctTexTileData, ctMap, ctMapData, + ctPalette, ctPaletteData, ctSequence, ctSequenceData, + ctSequenceFrame, // 3.00 + ctCorner, ctCornerData, + ctHEdge, ctHEdgeData, ctVEdge, ctVEdgeData, + ctTileMap, ctTile0, ctUTTile, + ctTileBitmap, ctTSTileBitmap, + ctList, + ctReadTextFile, ctReadBinFile + ); + + CommandRec = + record + KeyWord, + Parameters: string; + ReqCmd: set of CmdType; + idx: ^Integer; + NewLine: Boolean; + + sFilename, + sListName, + sBegin, + sSeparator, + sLongLineSeparator, + sNextSeparator, + sEnd, + sTrans: string; + + DataWidth, + DataHeight, + CodeStart: Integer; + end; + + const + SupportedCmds = [ctTile, ctTexTileData, ctCorner, ctCornerData, + ctMap, ctMapData, ctSequence, ctSequenceData, + ctSequenceFrame, + ctHEdge, ctHEdgeData, ctVEdge, ctVEdgeData, + ctTileData, ctTileMap, ctTile0, ctTSTile, + ctPalette, ctPaletteData, ctUTTile, + ctTileBitmap, ctTSTileBitmap, + ctList, + ctReadTextFile, ctReadBinFile + ]; + + const + Commands: array[CmdType] of CommandRec = + ( + ( KeyWord: 'FILE'; Parameters: 'F'; ReqCmd: []; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'BINFILE'; Parameters: 'FW'; ReqCmd: []; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'TILESET'; Parameters: 'S'; ReqCmd: []; idx: @itab; NewLine: TRUE; ), + ( KeyWord: 'TILE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @itile; NewLine: TRUE; ), + ( KeyWord: 'TSTILE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @itstile; NewLine: TRUE; ), + ( KeyWord: 'TINYTILES'; Parameters: 'WH'; ReqCmd: [ctTileSet]; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'TILEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctTile, ctTSTile]; idx: @idat; NewLine: FALSE; ), + ( KeyWord: 'TEXTILEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctTile, ctUTTile]; idx: @idat; NewLine: FALSE; ), + ( KeyWord: 'MAP'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @imap; NewLine: TRUE; ), + ( KeyWord: 'MAPDATA'; Parameters: 'BSLNE'; ReqCmd: [ctMap]; idx: @idat; NewLine: FALSE; ), + ( KeyWord: 'PALETTE'; Parameters: 'S'; ReqCmd: []; idx: @ipal; NewLine: TRUE; ), + ( KeyWord: 'PALETTEDATA'; Parameters: 'BSE'; ReqCmd: [ctPalette]; idx: @ipaldat; NewLine: FALSE; ), + ( KeyWord: 'SEQUENCE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @iseq; NewLine: TRUE; ), + ( KeyWord: 'SEQUENCEDATA'; Parameters: 'BSE'; ReqCmd: [ctSequence]; idx: @iseqdat; NewLine: FALSE; ), + ( KeyWord: 'SEQUENCEFRAME'; Parameters: 'BSE'; ReqCmd: [ctSequence]; idx: @iseqdat; NewLine: FALSE; ), + ( KeyWord: 'CORNER'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @icorner; NewLine: TRUE; ), + ( KeyWord: 'CORNERDATA'; Parameters: 'BSET'; ReqCmd: [ctCorner]; idx: @icornerdat; NewLine: FALSE; ), + ( KeyWord: 'HEDGE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @ihedge; NewLine: TRUE; ), + ( KeyWord: 'HEDGEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctHEdge]; idx: @ihedgedat; NewLine: FALSE; ), + ( KeyWord: 'VEDGE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @ivedge; NewLine: TRUE; ), + ( KeyWord: 'VEDGEDATA'; Parameters: 'BSLNET'; ReqCmd: [ctVEdge]; idx: @ivedgedat; NewLine: FALSE; ), + ( KeyWord: 'TILEMAP'; Parameters: 'BSLNE'; ReqCmd: [ctTile, ctTSTile]; idx: @itilemap; NewLine: FALSE; ), + ( KeyWord: 'TILE0'; Parameters: ''; ReqCmd: [ctTileSet]; idx: @itile0; NewLine: TRUE; ), + ( KeyWord: 'UNIQUETEXTILE'; Parameters: 'S'; ReqCmd: [ctTileSet]; idx: @iutt; NewLine: TRUE; ), + ( KeyWord: 'TILEBITMAP'; Parameters: 'X'; ReqCmd: []; idx: @itb; NewLine: FALSE; ), + ( KeyWord: 'TSTILEBITMAP'; Parameters: 'X'; ReqCmd: []; idx: @itb; NewLine: FALSE; ), + ( KeyWord: 'LIST'; Parameters: 'PBSLE'; ReqCmd: []; idx: nil; NewLine: FALSE; ), + ( KeyWord: 'READTEXTFILE'; Parameters: 'FBSLE'; ReqCmd: []; idx: @ifile; NewLine: FALSE; ), + ( KeyWord: 'READBINFILE'; Parameters: 'FBSLE'; ReqCmd: []; idx: @ifile; NewLine: FALSE; ) + ); + + + var + Done: Boolean; + s, t: string; + + FirstLine: Boolean; + WritingMapData: Boolean; + WritingTileData: Boolean; + WritingTexTileData: Boolean; + { WritingTinyTileData: Boolean; } + WritingSeqData: Boolean; + WritingSeqFrames: Boolean; // 3.0 + WritingPalData: Boolean; + WritingCornerData: Boolean; + OutputFileName: string; + OutputWidth: Integer; // 2.5 + F: TextFile; + TileSetStart, + MapStart, + MapDatStart, + TileStart, + TSTileStart, + { TinyTileStart, } + TileDatStart, + TexTileDatStart, + { TinyTileDatStart, } + SeqStart, + SeqDatStart, + PaletteStart, + PalDatStart, + CornerStart, + CornerDatStart: Integer; + fmtSequenceSeparator: string; + fmtStart, fmtSep, fmtSepOutputLine, + fmtSepLine, fmtEnd, fmtMapSep, fmtTileSep, + fmtTinyTileSep, + fmtTSSep, fmtPalSep, fmtTrans: string; + fmtCornerSep: string; + filepos: Integer; + LastPos: Integer; + + tmpi, tmpj: Integer; + + iCmd, + tmpCmd, + CurCmd: CmdType; + CmdList: string; + CmdOk: Boolean; + sMsg: string; + CurTrans: Boolean; + + // 3.0 + ListCount: Integer; + ListIdx: array of Integer; + ListDataWidth: array of Integer; + ListDataHeight: array of Integer; + ListCodeStart: array of Integer; + ListStr: array of String; + ListCmdRec: array of CommandRec; + tmpCmdRec: CommandRec; + + + + procedure WritePos (s: string); + var + i: Integer; + begin + + if WritingBinFile then + begin + if (s <> '') and (s[1] = #0) and (s[Length (s)] = #0) then + begin + Delete (s, Length (s), 1); + Delete (s, 1, 1); + end; + end + else + for i := 1 to Length (s) do + if s[i] in [#13, #10] then + filepos := 0 + else + Inc (filepos); + + Write (F, s); + end; + + + + + + procedure InitDatVars (Cmd: CmdType); + begin + case Cmd of + + ctTile, + ctTSTile, + ctTile0, + ctUTTile: InitTileVars (Cmd = ctTile0); + + ctTileData: CurTrans := not InitTileDatVars; + + ctTexTileData: CurTrans := not InitTexTileDatVars; + + ctMap: InitMapVars; + ctMapData: InitMapDatVars; + + ctPalette: InitPaletteVars; + ctPaletteData: InitPalDatVars; + + ctCorner: InitCornerVars; + ctCornerData: CurTrans := not InitCornerDatVars; + + ctSequence: InitSeqVars; + ctSequenceData: InitSeqDatVars; + ctSequenceFrame: InitSeqFrameVars; + + ctHEdge: InitHEdgeVars; + ctHEdgeData: CurTrans := not InitHEdgeDatVars; + + ctVEdge: InitVEdgeVars; + ctVEdgeData: CurTrans := not InitVEdgeDatVars; + + ctTileMap: InitTileMapVars; + + ctList: InitListVars (ListStr[ListCount - 1], ListIdx[ListCount - 1], ListCount - 1); + + ctReadTextFile, + ctReadBinFile: InitFileDatVars; + + end; + end; + + + begin { runcode / (generatecode) } + CodeError (0, ''); + Error := FALSE; + + SetLength (VarList, 0); + + SetNumVar ('TileSetCount', Tab.Tabs.Count); + SetNumVar ('TileSetNumber', -1); + + SetStrVar ('ProjectName', ProjectName); + + // new 2.0 + SetStrVar ('OutputDir', OutputPath); + SetStrVar ('CurrentDate', DateToStr (Date)); + SetStrVar ('CurrentTime', TimeToStr (Time)); + SetStrVar ('TSVersion', VERSION_NUMBER); + SetNumVar ('PaletteCount', Length (aaiPal)); + + SetStrVar ('shl', 'SHL'); + SetStrVar ('shr', 'SHR'); + SetStrVar ('if', 'IF'); + SetStrVar ('then', 'THEN'); + SetStrVar ('else', 'ELSE'); + SetStrVar ('not', 'NOT'); + SetStrVar ('equals', 'EQUALS'); + SetStrVar ('above', 'ABOVE'); + SetStrVar ('below', 'BELOW'); + + + with Info do + begin + SetStrVar ('Author', Author.Text); + SetStrVar ('Notes', Notes.Text); + SetStrVar ('Copyright', Copyright.Text); + end; + + + FilePos := 0; + CurPos := 1; + Done := FALSE; + WritingFile := FALSE; + WritingBinFile := FALSE; + FirstLine := FALSE; + WritingMapData := FALSE; + WritingTileData := FALSE; + WritingTexTileData := FALSE; + WritingCornerData := FALSE; + { WritingTinyTileData := FALSE; } + WritingSeqData := FALSE; + WritingSeqFrames := FALSE; + WritingPalData := FALSE; + itab := -1; + TileSetStart := -1; + imap := -1; + MapStart := -1; + idat := -1; + TileStart := -1; + TSTileStart := -1; + { TinyTileStart := -1; } + TileDatStart := -1; + TexTileDatStart := -1; + { TinyTileDatStart := -1; } + itile := -1; + itstile := -1; + { itinytile := -1; } + MapDatStart := -1; + iseq := -1; + SeqStart := -1; + iseqdat := -1; + SeqDatStart := -1; + OutputFileName := ''; + OutputWidth := 256; // 2.5 + SeqLen := -1; + ipal := -1; + PaletteStart := -1; + ipaldat := -1; + PalDatStart := -1; + + itilemap := -1; + icornerdat := -1; + CornerStart := -1; + + ListCount := 0; // 3.0 + + for tmpi := 0 to MAX_COUNTER do + Counters[tmpi] := 0; + + ReadingAhead := FALSE; + + ReadingTextFile := FALSE; + ReadingBinFile := FALSE; + InputFileName := ''; + InputFilePos := 0; + ifile := -1; + + + + StartWithEmptyTile := FALSE; + ExportDuplicateTiles := FALSE; // ignore unique tile check + + SetNumVar ('TRUE', 1); + SetNumVar ('FALSE', 0); + + + + + + CmdList := ''; + for tmpCmd := Low (CmdType) to High (CmdType) do + with Commands[tmpCmd] do + begin + if idx <> nil then + idx^ := -1; + CodeStart := -1; + end; + + + s := ''; + repeat + if s <> #0 then + s := GetTokenSpecial; + if s = '' then + Done := TRUE; + LastPos := CurPos; + t := LookAheadToken; + if (s = #0) and ((t = ';') or (t = '#')) then + begin + s := GetTokenSpecial; + if s = '!' then // ignore options here + begin + s := GetLine; + s := ''; + end; + if s = ';' then + begin + s := GetLine; + s := ''; + end; + if s = '#' then + begin + LastPos := CurPos; + s := UGetToken; + + // commands without #END could be placed here + // + // s := ''; + + if (s <> '') then + for iCmd := Low (CmdType) to High (CmdType) do + if iCmd in SupportedCmds then + with Commands[icmd] do + if s = KeyWord then + begin + if CurCmd <> CmdType (-1) then + Insert (Chr (Ord (CurCmd)), CmdList, 1); + CurCmd := iCmd; + + sMsg := ''; + CmdOk := ReqCmd = []; + for tmpCmd := Low (CmdType) to High (CmdType) do + if tmpCmd in ReqCmd then + begin + if sMsg <> '' then + sMsg := sMsg + ' / '; + sMsg := sMsg + Commands[tmpCmd].KeyWord; + if (Commands[tmpCmd].idx = nil) or (Commands[tmpCmd].idx^ >= 0) then + CmdOk := TRUE; + end; + if not CmdOk then + CodeError (LastPos, 'Only allowed between #' + sMsg + ' and #END ' + sMsg) + else + begin + tmpCmdRec := Commands[CurCmd]; + + sFilename := ''; + sListName := ''; + sBegin := ''; + sSeparator := ''; + sLongLineSeparator := ''; + sNextSeparator := ''; + sEnd := ''; + sTrans := ''; + + for tmpi := 1 to Length (Parameters) do + case Parameters[tmpi] of + 'F': sFilename := GetFilename; // GetString; 3.00 + 'P': begin // list (recursive) + sListName := GetString; + Inc (ListCount); + SetLength (ListIdx, ListCount); + SetLength (ListDataWidth, ListCount); + SetLength (ListDataHeight, ListCount); + SetLength (ListCodeStart, ListCount); + SetLength (ListStr, ListCount); + SetLength (ListCmdRec, ListCount); + ListIdx[ListCount - 1] := -1; + idx := @(ListIdx[ListCount - 1]); + ListDataWidth[ListCount - 1] := DataWidth; + ListDataHeight[ListCount - 1] := DataHeight; + ListCodeStart[ListCount - 1] := CodeStart; + ListStr[ListCount - 1] := sListName; + ListCmdRec[ListCount - 1] := tmpCmdRec; + end; + 'B': sBegin := GetStringOrToken; + 'S': sSeparator := GetStringOrToken; + 'L': if not WritingBinFile then + sLongLineSeparator := GetString; + 'N': sNextSeparator := GetStringOrToken; + 'E': sEnd := GetStringOrToken; + 'T': sTrans := GetStringOrToken; + + end; + + CodeStart := CurPos; + idx^ := 0; + + DataWidth := 0; + DataHeight := 1; + + case CurCmd of + + ctTile: if ValidTileSet then + if TinyTiles then + DataWidth := aFinalTinyTileCount[itab][TinyFlip] + else + DataWidth := aFinalTileCount[itab]; + + ctTile0: if ValidTileSet then + DataWidth := 1; + + ctTSTile: if ValidTSTileSet then + DataWidth := TileTab[itab].tbr.TileCount * GetTinyNH * GetTinyNV; + + ctTileData: if ValidTileSet then + if TinyTiles then + begin + DataWidth := TinyW; + DataHeight := TinyH; + end + else + begin // 2.53 - N parameter is now set + DataWidth := TileTab[itab].tbr.W; + DataHeight := TileTab[itab].tbr.H; + end; + // DataWidth := TileTab[itab].tbr.W * TileTab[itab].tbr.H; + + ctTexTileData: begin + DataWidth := TileTab[itab].tbr.W + 2; + DataHeight := TileTab[itab].tbr.H + 2; + end; + + ctMap: if ValidTileSet then + with TileTab[itab].tbr do + begin + DataWidth := Length (Maps.aMaps); + while (Maps.aMaps[imap].SkipExport = TRUE) do + Inc (imap); + end; + + ctMapData: begin + DataWidth := MapWd; + DataHeight := MapHt; + end; + + ctCorner: DataWidth := aCornerCount[itab]; + + ctCornerData: DataWidth := 4; + + ctSequence: if ValidTileSet then + with TileTab[itab].tbr do + DataWidth := GetTinyNH * GetTinyNV * + Length (Seq.aMaps); + + ctSequenceData: if ValidTileSet then + DataWidth := SeqLen; + + ctSequenceFrame: if ValidTileSet then + DataWidth := SeqFrames; + + ctHEdge: DataWidth := aHEdgeCount[itab]; + + ctHEdgeData: begin + DataWidth := TileTab[itab].tbr.W; + DataHeight := 2; + end; + + ctVEdge: DataWidth := aVEdgeCount[itab]; + + ctVEdgeData: begin + DataWidth := 2; + DataHeight := TileTab[itab].tbr.H; + end; + + ctTileMap: begin + DataWidth := TinyNH; + DataHeight := TinyNV; + end; + + ctPalette: DataWidth := Length (aaiPal); + + ctPaletteData: DataWidth := aiPalSize[ipal]; // Length (aaiPal[ipal]); + + + ctUTTile: if ValidTileSet then + DataWidth := aUTTCount[itab]; + + ctTileBitmap, + ctTSTileBitmap: begin + DataWidth := 1; + DataHeight := 1; + end; + + ctList: DataWidth := GetListLength (sListName); + + ctReadTextFile: if sFilename <> '' then + begin + InputFileName := AdjustFilename (sFilename, OutputPath); + if InputFileName <> '' then + begin + DataWidth := GetTextFileLineCount (InputFileName); + AssignFile (TI, InputFileName); + Reset (TI); + ReadingTextFile := TRUE; + InputFilePos := 0; + end; + end; + + ctReadBinFile: if sFilename <> '' then + begin + InputFileName := AdjustFilename (sFilename, OutputPath); + if InputFileName <> '' then + begin + DataWidth := GetBinFileSize (InputFileName); + AssignFile (FI, InputFileName); + Reset (FI); + ReadingBinFile := TRUE; + InputFilePos := 0; + end; + end; + + end; + + if (idx^ >= DataWidth * DataHeight) or + (DataWidth * DataHeight <= 0) then + begin + FindEnd (s); + + idx^ := -1; + CodeStart := -1; + + if CurCmd = ctList then + begin + Dec (ListCount); + if ListCount > 0 then + begin + Commands[CurCmd] := ListCmdRec[ListCount]; + DataWidth := ListDataWidth[ListCount]; + DataHeight := ListDataHeight[ListCount]; + CodeStart := ListCodeStart[ListCount]; + idx := @(ListIdx[ListCount - 1]); + end + else + idx := nil; + SetLength (ListIdx, ListCount); + SetLength (ListDataWidth, ListCount); + SetLength (ListDataHeight, ListCount); + SetLength (ListCodeStart, ListCount); + SetLength (ListStr, ListCount); + SetLength (ListCmdRec, ListCount); + end; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end + else + InitDatVars (CurCmd); + + end; + if not (Pos ('X', Commands[CurCmd].Parameters) > 0) then + begin + s := ''; + FilePos := 0; + end; + end; + + + if s = 'FILE' then + begin + if WritingFile or WritingBinFile then + CodeError (LastPos, 'Already writing a file') + else + begin + OutputFileName := GetFilename; + + if OutputFileName <> '' then + begin + if (Pos (':', OutputFileName) = 2) or (OutputFileName[1] = '\') then + AssignFile (F, OutputFileName) + else + begin + CreatePath (OutputPath + OutputFileName); // 2.54 bug fix + AssignFile (F, OutputPath + OutputFileName); + end; + ReWrite (F); + WritingFile := TRUE; + FirstLine := TRUE; + end; + end; + s := ''; + end; + + if s = 'BINFILE' then + begin + if WritingFile or WritingBinFile then + CodeError (LastPos, 'Already writing a file') + else + begin + OutputFileName := GetFilename; + if OutputFileName <> '' then + begin + if (Pos (':', OutputFileName) = 2) or (OutputFileName[1] = '\') then + AssignFile (F, OutputFileName) + else + begin + CreatePath (OutputPath + OutputFileName); // 2.54 bug fix + AssignFile (F, OutputPath + OutputFileName); + end; + ReWrite (F); + WritingBinFile := TRUE; + // FirstLine := TRUE; + end; + + DefaultBinFileBits := 8; + tmpi := -1; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + tmpi := StrToInt (s); + end; + if tmpi in [8, 16, 24, 32] then + DefaultBinFileBits := tmpi + else + CodeError (LastPos, 'Allowed values are 8, 16, 24 or 32 bits'); + + end; + s := ''; + end; + + + + (* + // 2.0 + if s = 'PALETTE' then + begin + fmtPalSep := GetString; + PaletteStart := CurPos; + ipal := 0; + + { 2.1 } + if (ipal >= 0) and (Length (aaiPal) > 0) and + (PaletteManager.GetID (ipal) <> '') then + InitPaletteVars + else + FindEnd (s); + s := ''; + end; + // + + // 2.4 + if s = 'CORNER' then + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + fmtCornerSep := GetString; + CornerStart := CurPos; + icorner := 0; + + if not InitCornerVars then + FindEnd (s); + s := ''; + end; + // + *) + + + // 2.2 + if s = 'TINYTILES' then + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + tmpi := -1; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + tmpi := StrToInt (s); + end; + + tmpj := -1; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + tmpj := StrToInt (s); + end; + + if (tmpi <= 0) or (tmpj <= 0) then + CodeError (LastPos, 'Illegal size value(s)') + else + begin + + if ValidTileSet then + SetupTinyTiles (tmpi, tmpj, NOFLIP) + else + begin + TinyW := tmpi; + TinyH := tmpj; + + end; + + if (TinyW <= 0) or (TinyH <= 0) then + FindEnd ('TINYTILES') + else + begin + with TileTab[itab] do + begin + TinyNH := tbr.W div TinyW; + TinyNV := tbr.H div TinyH; + end; + + TinyTiles := TRUE; + + InitTileSetVars; + + end; + end; + s := ''; + end; + + + if s = 'TILESET' then + begin + fmtTSSep := GetStringOrToken; // 2.0 + TileSetStart := CurPos; + itab := 0; + ShowProgress (0, 100); // 2.53 + if GetValidTileSet then + InitTileSetVars + else + FindEnd (s); + s := ''; + end; + + + if s = 'TSTILEBITMAP' then // 2.5 + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + OutputFileName := GetFilename; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + OutputWidth := StrToInt (s); + end; + + s := ''; + end; + + + if s = 'TILEBITMAP' then + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + begin + OutputFileName := GetFilename; + s := LookAheadToken; + while s = ' ' do + begin + s := GetToken; + s := LookAheadToken; + end; + if ValidNumber (s) then + begin + s := GetToken; + WidenBitmap (StrToInt (s)); + InitTileSetVars; + end; + + s := ''; + end; + + + if (s = ';') or (s = '#') then + begin + if WritingFile then + begin + if not FirstLine then + WriteLn (F); + FirstLine := FALSE; + Write (F, s); + end; + s := ''; + end; + + + + if s = 'END' then + begin + s := USGetToken; + + + // 2.2 + if s = 'TINYTILES' then + begin + TinyTiles := FALSE; + + InitTileSetVars; + + TinyW := -1; + TinyH := -1; + s := ''; + end; + + + if s = 'FILE' then + begin + if not WritingFile then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + CloseFile (F); + WritingFile := FALSE; + FirstLine := FALSE; + OutputFileName := ''; + end; + s := ''; + end; + + if s = 'BINFILE' then + begin + if not WritingBinFile then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + CloseFile (F); + WritingBinFile := FALSE; + // FirstLine := FALSE; + OutputFileName := ''; + end; + s := ''; + end; + + + if (CurCmd in SupportedCmds) and (s <> '') then + with Commands[CurCmd] do + begin + if (s <> KeyWord) or (idx^ < 0) or (CodeStart < 0) then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + + // next ... + case CurCmd of + ctMap: + with TileTab[itab].tbr do + begin + Inc (imap); + + while (imap <= Length (Maps.aMaps) - 1) and // 2.43 bug fix (last map was always exported) + (Maps.aMaps[imap].SkipExport = TRUE) do + Inc (imap); + + if imap < Length (Maps.aMaps) then + if WritingFile or WritingBinFile then + WritePos (sSeparator); + end; + + else + if WritingFile or WritingBinFile then + begin + if idx^ mod DataWidth = DataWidth - 1 then + begin + if idx^ = DataWidth * DataHeight - 1 then + WritePos (sEnd) + else + if Pos ('N', Parameters) > 0 then + WritePos (sNextSeparator) + else + WritePos (sSeparator); + end + else + if (FilePos > LONG_LINE) and (Pos ('L', Parameters) > 0) then + WritePos (sLongLineSeparator) + else + WritePos (sSeparator); + end; + + Inc (idx^); + + end; + + if not (Pos ('X', Commands[CurCmd].Parameters) > 0) then + begin + if (idx^ < DataWidth * DataHeight) then + begin + CurPos := CodeStart; + + InitDatVars (CurCmd); + + end + else + begin + idx^ := -1; + CodeStart := -1; + + // finally ... + case CurCmd of + ctList: + begin + Dec (ListCount); + if ListCount > 0 then + begin + Commands[CurCmd] := ListCmdRec[ListCount]; + DataWidth := ListDataWidth[ListCount]; + DataHeight := ListDataHeight[ListCount]; + CodeStart := ListCodeStart[ListCount]; + idx := @(ListIdx[ListCount - 1]); + end + else + idx := nil; + SetLength (ListIdx, ListCount); + SetLength (ListDataWidth, ListCount); + SetLength (ListDataHeight, ListCount); + SetLength (ListCodeStart, ListCount); + SetLength (ListStr, ListCount); + SetLength (ListCmdRec, ListCount); + end; + + ctReadTextFile: + begin + CloseFile (TI); + ReadingTextFile := FALSE; + InputFileName := ''; + end; + ctReadBinFile: + begin + CloseFile (FI); + ReadingBinFile := FALSE; + InputFileName := ''; + end; + + end; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end; + end; + + end; + if not (Pos ('X', Commands[CurCmd].Parameters) > 0) then + s := ''; + end; + + + + if s = 'TILESET' then + begin + if TileSetStart = -1 then + CodeError (LastPos, 'Misplaced #END statement') + else + begin + Inc (itab); + ShowProgress (0, 100); // 2.53 + if GetValidTileSet then + begin + if WritingFile or WritingBinFile then + WritePos (fmtTSSep); // 2.0 + CurPos := TileSetStart; + InitTileSetVars; + end + else + begin + itab := -1; + SetNumVar ('TileSetNumber', itab); + TileSetStart := -1; + + if (ipal <> -1) and (PaletteStart = -1) then // 2.0 + ipal := -1; + end; + end; + s := ''; + end; + + + if s = 'TSTILEBITMAP' then // 2.5 + begin + if itab = -1 then + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + if OutputFileName <> '' then + with TileTab[itab] do + begin + if not ((Pos (':', OutputFileName) = 2) or // 2.54 bug fix + (OutputFileName[1] = '\')) then + begin + OutputFilename := OutputPath + OutputFileName; + CreatePath (OutputFilename); + end; + + if itstile >= 0 then // 2.54 + begin + idat := 0; + DataW := TileTab[itab].tbr.W; + DataH := TileTab[itab].tbr.H; + bmpCurTile.Width := DataW; + bmpCurTile.Height := DataH; + while idat < DataW * DataH do + begin + CurTrans := not InitTileDatVars; + if CurTrans then + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := TRANS_COLOR + else + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := CurRGB; + Inc (idat); + end; + idat := -1; + bmpCurTile.PixelFormat := pfOutput; + + while (OutputFilename <> '') and (OutputFilename[Length (OutputFilename)] in [' ', #0]) do + Delete (OutputFilename, Length (OutputFilename), 1); + if UpperCase (ExtractFileExt (OutputFilename)) = '.PNG' then + WriteBitmapToPngFile ({OutputPath +} OutputFilename, bmpCurTile, TRANS_COLOR) + else + begin + bmpCurTile.SaveToFile ({OutputPath +} OutputFileName); + {$IFDEF PATCHBMP} + PatchBMPFile ({OutputPath +} OutputFileName); + {$ENDIF} + end; + + end + else + + WriteTileBitmap ({OutputPath +} OutputFileName, + OutputWidth, + TRANS_COLOR, + 0, { border color } + 0, 0, 0, 0, { border w/h / edge w/h } + tbr, + ProgressBar, + FALSE, { bottom right transparent } + FALSE, { store bounds } + 1 { = pf24bit } + ); + + OutputFileName := ''; + + + + + with Commands[CurCmd] do + begin + idx^ := -1; + CodeStart := -1; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end; + + + + end; + s := ''; + end; + + + if s = 'TILEBITMAP' then + begin + if itab = -1 then // 2.5 + CodeError (LastPos, 'Only allowed between #TILESET and #END TILESET') + else + + if OutputFileName <> '' then + begin + + if itile >= 0 then // 2.54 + begin + idat := 0; + DataW := TileTab[itab].tbr.W; + DataH := TileTab[itab].tbr.H; + bmpCurTile.Width := DataW; + bmpCurTile.Height := DataH; + while idat < DataW * DataH do + begin + CurTrans := not InitTileDatVars; + if CurTrans then + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := TRANS_COLOR + else + bmpCurTile.Canvas.Pixels[idat mod DataW, idat div DataW] := CurRGB; + Inc (idat); + end; + idat := -1; + + + if not ((Pos (':', OutputFileName) = 2) or // 2.54 bug fix + (OutputFileName[1] = '\')) then + begin + OutputFilename := OutputPath + OutputFileName; + CreatePath (OutputFilename); + end; + + + bmpCurTile.PixelFormat := pfOutput; + while (OutputFilename <> '') and (OutputFilename[Length (OutputFilename)] in [' ', #0]) do + Delete (OutputFilename, Length (OutputFilename), 1); + if UpperCase (ExtractFileExt (OutputFilename)) = '.PNG' then + WriteBitmapToPngFile ({OutputPath +} OutputFilename, bmpCurTile, TRANS_COLOR) + else + begin + bmpCurTile.SaveToFile ({OutputPath +} OutputFileName); + {$IFDEF PATCHBMP} + PatchBMPFile ({OutputPath +} OutputFileName); + {$ENDIF} + end; + end + else + begin { itile = 0, write complete bitmap } + + if not ((Pos (':', OutputFileName) = 2) or // 2.55 bug fix + (OutputFileName[1] = '\')) then + begin + OutputFilename := OutputPath + OutputFileName; + CreatePath (OutputFilename); + end; + + + if bmpFinal[itab].Height > 0 then + begin + CreatePath ({OutputPath +} OutputFileName); + bmpFinal[itab].PixelFormat := pfOutput; + while (OutputFilename <> '') and (OutputFilename[Length (OutputFilename)] in [' ', #0]) do + Delete (OutputFilename, Length (OutputFilename), 1); + if UpperCase (ExtractFileExt (OutputFilename)) = '.PNG' then + WriteBitmapToPngFile ({OutputPath +} OutputFilename, bmpFinal[itab], TRANS_COLOR) + else + begin + bmpFinal[itab].SaveToFile ({OutputPath +} OutputFileName); + {$IFDEF PATCHBMP} + PatchBMPFile ({OutputPath +} OutputFileName); + {$ENDIF} + end; + end; + + end; + OutputFileName := ''; + + + with Commands[CurCmd] do + begin + idx^ := -1; + CodeStart := -1; + + if CmdList <> '' then + begin + CurCmd := CmdType (CmdList[1]); + Delete (CmdList, 1, 1); + end + else + CurCmd := CmdType (-1); + end; + + + end; + s := ''; + end; + + + + end; + end; + if s <> '' then + CodeError (LastPos, 'Syntax error'); + s := ''; + end + +{ } + + else + if CurCmd in SupportedCmds then + with Commands[CurCmd] do + begin + + repeat + if WritingFile or WritingBinFile then + if s <> #0 then + begin + if idx^ = 0 then + WritePos (sBegin); + + if CurTrans and (sTrans <> '') then + WritePos (sTrans) + else + WritePos (s); + + end + else + if not WritingBinFile then + if NewLine then + begin + if not FirstLine then + WritePos (#13#10); + FirstLine := FALSE; + end; + + s := GetTokenSpecial; + t := LookAheadToken; + while (s <> #0) and (t <> #0) and (t <> '') do + begin + if WritingBinFile then + begin + WritePos (s); + s := ''; + end; + s := s + GetTokenSpecial; + t := LookAheadToken; + end; + until (s = #0) or (s = '') or Done or Error; + + end + +{ } + + else + if WritingSeqData or WritingSeqFrames or WritingPalData then + begin + repeat + if WritingFile or WritingBinFile then + if s <> #0 then + begin + if (WritingSeqData and (iseqdat = 0)) or + (WritingSeqFrames and (iseqdat = 0)) or + (WritingPalData and (ipaldat = 0)) then + WritePos (fmtStart); + WritePos (s); + if (WritingSeqData and (iseqdat = SeqLen - 1)) or + (WritingSeqFrames and (iseqdat = SeqFrames - 1)) or + (WritingPalData and (ipaldat = { Length (aaiPal[ipal]) } aiPalSize[ipal] - 1)) then // 2.41 + WritePos (fmtEnd) + else + WritePos (fmtSep); + end; + s := GetTokenSpecial; + t := LookAheadToken; + while (s <> #0) and (t <> #0) and (t <> '') do + begin + s := s + GetTokenSpecial; + t := LookAheadToken; + end; + until (s = #0) or (s = '') or Done or Error; + end + else + if WritingMapData + or WritingTileData + or WritingTexTileData + or WritingCornerData + { or WritingTinyTileData } then + begin + itmpdat := idat; + if WritingMapData then + begin + tmpW := MapWd; + tmpH := MapHt; + end; + if WritingTileData then + if TinyTiles then + begin + tmpW := TinyW; + tmpH := TinyH; + end + else + begin + tmpW := TileTab[itab].tbr.W; + tmpH := TileTab[itab].tbr.H; + end; + if WritingTexTileData then + begin + tmpW := TileTab[itab].tbr.W + 2; + tmpH := TileTab[itab].tbr.H + 2; + end; + if WritingCornerData then + begin + tmpW := 4; + tmpH := 1; + itmpdat := icornerdat; + end; + + repeat + if WritingFile or WritingBinFile then + if s <> #0 then + begin + if itmpdat = 0 then + WritePos (fmtStart); + + if WritingTileData or WritingTexTileData or WritingCornerData then + begin + if TransReplace = '' then + WritePos (s) + else + if TransReplace <> #0 then + begin + WritePos (TransReplace); + TransReplace := #0; + end; + end + else + WritePos (s); + + if itmpdat mod tmpW = tmpW - 1 then + if itmpdat = tmpW * tmpH - 1 then + WritePos (fmtEnd) + else + WritePos (fmtSepLine) + else + if FilePos > LONG_LINE then + WritePos (fmtSepOutputLine) + else + WritePos (fmtSep); + + end; + + s := GetTokenSpecial; + t := LookAheadToken; + while (s <> #0) and (t <> #0) and (t <> '') do + begin + s := s + GetTokenSpecial; + t := LookAheadToken; + end; + until (s = #0) or (s = '') or Done or Error; + end + else + begin + + repeat + if WritingFile then + begin + if s = #0 then + begin + if not FirstLine then + WriteLn (F); + end + else + Write (F, s); + FirstLine := FALSE; + end; + + if WritingBinFile then + if s <> #0 then + WritePos (s); + + s := GetTokenSpecial; + until (s = #0) or (s = '') or Done or Error; + + end; + + until Done or Error; + + + if WritingFile or WritingBinFile then + CloseFile (F); + + // for itab := 0 to Tab.Tabs.Count - 1 do + + if not Error then + ErrorMsg := ''; + + SetLength (VarList, 0); + + + RunCode := ErrorMsg; + end; + + + procedure ReadCodeOptions (lines: TStrings); + var + i: Integer; + s: string; + begin + + for i := 0 to lines.Count - 1 do + begin + s := UpCaseStr (Trim(lines.Strings[i])); + if (s <> '') then + begin + if (s[1] = '!') then + begin + Delete (s, 1, 1); + + if (s = 'RUNCMDLINE') then // run command line + begin + RunCMDLine := UpCaseStr (Trim(lines.Strings[i+1])); // read next line + Delete (RunCMDLine, 1, 1); // remove first char + end; + + if (s = 'STARTWITHEMPTYTILE') then + begin + StartWithEmptyTile := TRUE; + end; + + if (s = 'EXPORTDUPLICATETILES') then + begin + ExportDuplicateTiles := TRUE; // ignore unique tile check + end; + + + + end; + end; + + end; +end; + +// from https://stackoverflow.com/questions/32211723/why-delphi-app-cant-run-a-bat-file-and-make-it-work?noredirect=1&lq=1 +procedure StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); +var + StartInfo: TStartupInfo; + ProcInfo: TProcessInformation; +begin + //Simple wrapper for the CreateProcess command + //returns the process id of the started process. + FillChar(StartInfo,SizeOf(TStartupInfo),#0); + FillChar(ProcInfo,SizeOf(TProcessInformation),#0); + StartInfo.cb := SizeOf(TStartupInfo); + + if not(ShowWindow) then begin + StartInfo.dwFlags := STARTF_USESHOWWINDOW; + StartInfo.wShowWindow := SW_HIDE; + end; + + CreateProcess(nil,PChar(ExeName + ' ' + CmdLineArgs),nil,nil,False, + CREATE_NEW_PROCESS_GROUP + NORMAL_PRIORITY_CLASS,nil,nil,StartInfo, + ProcInfo); + + //Result := ProcInfo.dwProcessId; + + if WaitForFinish then begin + WaitForSingleObject(ProcInfo.hProcess,Infinite); + end; + + //close process & thread handles + CloseHandle(ProcInfo.hProcess); + CloseHandle(ProcInfo.hThread); +end; + +{ TMainForm.Generate1Click } + + var + i, j, k: Integer; + x, y: Integer; + mcr: MapCellRec; + m, u, r: Boolean; + found, diff: Boolean; + N: Integer; + rr, gg, bb: Integer; + tr, tg, tb, ta: Integer; + ii, jj, kk: Integer; + ErrMsg: string; + corner: Integer; + +begin + if CodeGen.LastDef = '' then + begin + MessageDlg ('Please select a code generation definition first.', + mtInformation, [mbOk], 0); + Exit; + end; + + CodeGen.ProjectDir := FilePath (FileName); // 2.5 + code := CodeGen.GetCodeString; + + + if code = '' then + begin + MessageDlg ('Cannot read code generation definition file (' + + CodeGen.LastDef + ').', mtError, [mbOk], 0); + Exit; + end; + + + ReadCodeOptions (CodeGen.Memo.Lines); + + + { + ShowBackLayer.Checked := TRUE; + ShowMidLayer.Checked := TRUE; + ShowFrontLayer.Checked := TRUE; + } + + ProgressPanel.Visible := TRUE; + with ProgressBar do + begin + Min := 0; + Max := 100 * Tab.Tabs.Count; + Position := 0; + end; + + + if aaN < 2 then + aaN := 1; + aa := (aaN >= 2); + aaX := aaN; + aaY := aaN; + + + + SetLength (aMCR, Tab.Tabs.Count); + SetLength (aFinalRef, Tab.Tabs.Count); + SetLength (bmpFinal, Tab.Tabs.Count); + SetLength (bmpAlpha, Tab.Tabs.Count); + SetLength (aFinalTileCount, Tab.Tabs.Count); + SetLength (TransX, Tab.Tabs.Count); + SetLength (TransY, Tab.Tabs.Count); + + SetLength (aFinalTinyTileCount, Tab.Tabs.Count); + SetLength (aFinalTinyTiles, Tab.Tabs.Count); + SetLength (aFinalTinyRef, Tab.Tabs.Count); + TinyW := -1; + TinyH := -1; + TinyFlip := NOFLIP; + TinyTiles := FALSE; + + // 2.4 + TexTiles := { (Pos (#0'#TEXTILEBITMAP', UpCaseStr (code)) > 0) or } + (Pos (#0'#TEXTILEDATA', UpCaseStr (code)) > 0) or + (Pos (#0'#CORNER', UpCaseStr (code)) > 0) or + (Pos (#0'#HEDGE', UpCaseStr (code)) > 0) or + (Pos (#0'#VEDGE', UpCaseStr (code)) > 0); + // 2.5 + UTT := TexTiles and (Pos (#0'#UNIQUETEXTILE', UpCaseStr (code)) > 0); + + + SetLength (aTransTile, Tab.Tabs.Count); + + if TexTiles then + begin + SetLength (bmpTexTiles, Tab.Tabs.Count); + SetLength (bmpTexAlpha, Tab.Tabs.Count); + SetLength (aMCRSur, Tab.Tabs.Count); + SetLength (aSameAs, Tab.Tabs.Count); + SetLength (aTrans, Tab.Tabs.Count); + SetLength (Corners, Tab.Tabs.Count); + SetLength (HEdges, Tab.Tabs.Count); + SetLength (VEdges, Tab.Tabs.Count); + SetLength (aCornerCount, Tab.Tabs.Count); + SetLength (aHEdgeCount, Tab.Tabs.Count); + SetLength (aVEdgeCount, Tab.Tabs.Count); + + if UTT then + begin + SetLength (aUTTRef, Tab.Tabs.Count); + SetLength (aUTTIndex, tab.Tabs.Count); + SetLength (aUTTCount, Tab.Tabs.Count); + end; + end; + + + + + for itab := 0 to Tab.Tabs.Count - 1 do + with TileTab[itab].tbr do + begin + LastW := W; + LastH := H; + end; + + + bmpCurTile := TBitmap.Create; + SetStretchBltMode(bmpCurTile.Canvas.Handle, HALFTONE); + bmpCurTile.PixelFormat := pf24bit; + bmpCurTile.Canvas.Brush.Color := TRANS_COLOR; + + for itab := 0 to Tab.Tabs.Count - 1 do + begin + ShowProgress (0, 100); + + with TileTab[itab] do + begin + + bmp1.Width := tbr.W; + bmp1.Height := tbr.H; + ResizeBitmap (bmp1); + + bmp2.Width := tbr.W; + bmp2.Height := tbr.H; + ResizeBitmap (bmp2); + + bmpFinal[itab] := TBitmap.Create; + SetStretchBltMode(bmpFinal[itab].Canvas.Handle, HALFTONE); + bmpFinal[itab].PixelFormat := pf24bit; + bmpFinal[itab].Width := tbr.W; + bmpFinal[itab].Canvas.Brush.Color := TRANS_COLOR; + + SetLength (aMCR[itab], 0); + N := 0; + + // 2.4 + if TexTiles then + begin + bmpTexTiles[itab] := TBitmap.Create; + SetStretchBltMode(bmpTexTiles[itab].Canvas.Handle, HALFTONE); + bmpTexTiles[itab].PixelFormat := pf24bit; + bmpTexTiles[itab].Width := tbr.W + 2; + bmpTexTiles[itab].Canvas.Brush.Color := TRANS_COLOR; + end; + + // make a collection of all unique MCR's + + with mcr do + begin + Back := -1; + Mid := -1; + Front := -1; + end; + AddMCR (mcr); + + with tbr.Maps do + for i := 0 to Length (aMaps) - 1 do + AddMCRs (aMaps[i].map); + + with tbr.Seq do + for i := 0 to Length (aMaps) - 1 do + AddMCRs (aMaps[i].map); + + SetLength (aFinalRef[itab], Length (aMCR[itab])); + + + // create tile bitmap with unique tiles + + for i := 0 to Length (aMCR[itab]) - 1 do + begin + mcr := aMCR[itab][i]; + FillBitmap (bmp2, TRANS_COLOR); + + with mcr do + begin + if mcr.Back <> -1 then + DrawTile (itab, mcr.Back, bmp1, m, u, r, bmp2); + if mcr.Mid <> -1 then + DrawTile (itab, mcr.Mid, bmp1, m, u, r, bmp2); + if mcr.Front <> -1 then + DrawTile (itab, mcr.Front, bmp1, m, u, r, bmp2); + end; + + found := FALSE; + for j := 0 to N - 1 do + if not found then + begin + diff := ExportDuplicateTiles; // ignore unique tile check + for y := 0 to tbr.H - 1 do + if not diff then + for x := 0 to tbr.W - 1 do + if not diff then + if bmp2.Canvas.Pixels[x, y] <> + bmpFinal[itab].Canvas.Pixels[x, y + j * tbr.H] then + diff := TRUE; + if not diff then + begin + aFinalRef[itab][i] := j; + found := TRUE; + end; + end; + +{$IFNDEF PATCHBMP} + { work around for SaveToFile BMP header error with pf24bit } + bmpFinal[itab].PixelFormat := pfFinal; +{$ENDIF} + + if not found then + begin + Inc (N); + + bmpFinal[itab].Height := N * tbr.H; + with tbr do + bmpFinal[itab].Canvas.CopyRect + (MakeRect (0, (N - 1) * H, W, H), + bmp2.Picture.Bitmap.Canvas, + Rect (0, 0, W, H)); + aFinalRef[itab][i] := N - 1; + end; + end; + + + // scale down bmpFinal bitmap for anti-aliasing + if aa then + begin + bmpAlpha[itab] := TBitmap.Create; + bmpAlpha[itab].PixelFormat := pf8bit; + bmpAlpha[itab].Width := tbr.W div aaX; + bmpAlpha[itab].Height := N * tbr.H div aaY; + + with tbr, bmpFinal[itab] do + begin + for k := 0 to N - 1 do + for j := 0 to (H {+ aaY - 1}) div aaY - 1 do + for i := 0 to (W {+ aaX - 1}) div aaX - 1 do + begin + tr := 0; tg := 0; tb := 0; ta := 0; + + kk := 0; + for jj := 0 to aaY - 1 do + for ii := 0 to aaX - 1 do + if (j * aaY + jj < H) and (i * aaX + ii < W) then + begin + GetRGB (Canvas.Pixels[i * aaX + ii, k * H + j * aaY + jj], rr, gg, bb); + if RGB (rr, gg, bb) <> TRANS_COLOR then + begin + tr := tr + rr; + tg := tg + gg; + tb := tb + bb; + ta := ta + 255; + Inc (kk); + end; + end; + + + if ta = 0 then + Canvas.Pixels[i, j + k * ((H {+ aaY - 1}) div aaY)] := TRANS_COLOR + else + Canvas.Pixels[i, j + k * ((H {+ aaY - 1}) div aaY)] := + RGB (tr div kk, tg div kk, tb div kk); + + bmpAlpha[itab].Canvas.Pixels[i, j + k * ((H {+ aaY - 1}) div aaY)] := + ta div (aaX * aaY); + end; + + W := (W {+ aaX - 1}) div aaX; + H := (H {+ aaY - 1}) div aaY; + + Width := Width div aaX; + Height := Height div aaY; + end; + end; + + + // find a transparent pixel, or add transparent tile to the end + TransX[itab] := -1; + TransY[itab] := -1; + + with tbr, bmpFinal[itab] do + if Height > 0 then + begin + if StartWithEmptyTile then + begin + TransX[itab] := 0; + TransY[itab] := 0; + end + else + begin + for i := 1 to N - 1 do + begin + Canvas.CopyRect (MakeRect (0, (i - 1) * H, W, H), + Canvas, MakeRect (0, i * H, W, H)); + if aa then + with bmpAlpha[itab] do + Canvas.CopyRect (MakeRect (0, (i - 1) * H, W, H), + Canvas, MakeRect (0, i * H, W, H)); + end; + for j := 0 to Height - 1 do + for i := 0 to W - 1 do + if Canvas.Pixels[i, j] = TRANS_COLOR then + begin + TransX[itab] := i; + TransY[itab] := j; + end; + if TransX[itab] <> -1 then + begin + aTransTile[itab] := 0; + Height := Height - H; + end + else + begin + for j := 0 to H - 1 do + for i := 0 to W - 1 do + Canvas.Pixels[i, Height - 1 - j] := TRANS_COLOR; + aTransTile[itab] := 1; + end; + end; + + + // aFinalTileCount[itab] := N; + aFinalTileCount[itab] := bmpFinal[itab].Height div H; // 2.34 + + // 2.4 + if TexTiles then + begin + i := aFinalTileCount[itab]; + bmpTexTiles[itab].Width := W + 2; + bmpTexTiles[itab].Height := i * (H + 2); + for j := 0 to i - 1 do + bmpTexTiles[itab].Canvas.CopyRect (MakeRect (1, j * (H + 2) + 1, W, H), + Canvas, MakeRect (0, j * H, W, H)); + + if aa then + begin + bmpTexAlpha[itab] := TBitmap.Create; + bmpTexAlpha[itab].PixelFormat := pf8bit; + bmpTexAlpha[itab].Width := W + 2; + bmpTexAlpha[itab].Height := i * (H + 2); + with bmpAlpha[itab] do + for j := 0 to i - 1 do + bmpTexAlpha[itab].Canvas.CopyRect (MakeRect (1, j * (H + 2) + 1, W, H), + Canvas, MakeRect (0, j * H, W, H)); + end; + + end; + end; + + + if TexTiles then + begin + + SetLength (aMCRSur[itab], Length (aFinalRef[itab])); + SetLength (aSameAs[itab], Length (aFinalRef[itab])); + SetLength (aTrans[itab], Length (aFinalRef[itab])); + SetLength (Corners[itab], 0); + SetLength (HEdges[itab], 0); + SetLength (VEdges[itab], 0); + + if UTT then + begin + SetLength (aUTTRef[itab], Length (aFinalRef[itab])); + SetLength (aUTTIndex[itab], Length (aFinalRef[itab])); + end; + + { ... edges and corners ... } + + SetEdgeRects (tbr.W, tbr.H); + + with tbr.Maps do + for i := 0 to Length (aMaps) - 1 do + CreateEdgeData (aMaps[i].map, tbr.Seq); + + FindSameEdges; + GetEdgeColors; + + for j := 0 to Length (aMCRSur[itab]) - 1 do + begin + for i := 0 to 7 do + if EdgeToCorner[i] = -1 then + begin + + k := GetMostSurTile (itab, j, i); + + + if k > -1 then + with tbr do + bmpTexTiles[itab].Canvas.CopyRect + (AddRect (EdgeDst[i], MakeRect (0, (j - 1) * (H + 2), 0, 0)), + bmpTexTiles[itab].Canvas, + AddRect (EdgeSrc[i], MakeRect (0, (k - 1) * (H + 2), 0, 0))); + + end; + + for i := 0 to 7 do + if EdgeToCorner[i] <> -1 then + begin + corner := 3 - EdgeToCorner[i]; + x := TileCornerX[corner]; + y := TileCornerY[corner] + (j - 1) * (H + 2); + with bmpTexTiles[itab].Canvas do + begin + TmpCorner[0] := Pixels[x, y]; + TmpCorner[1] := Pixels[x + 1, y]; + TmpCorner[2] := Pixels[x, y + 1]; + TmpCorner[3] := Pixels[x + 1, y + 1]; + end; + TmpCorner[corner] := -1; + + k := GetBestCorner (j, EdgeToCorner[i], TmpCorner); + + if k <> -1 then + begin + TmpCorner[corner] := Corners[itab][k].Colors[corner]; + with tbr do + bmpTexTiles[itab].Canvas.Pixels[EdgeDst[i].Left, + (j - 1) * (H + 2) + EdgeDst[i].Top] := + TmpCorner[corner]; + end; + + CreateCornerData (j, i, k, TmpCorner); + + end; + end; + + aCornerCount[itab] := NumberCornerData; + SortMCRSur; + + CreateHVEdgeData; + + + + // 2.5 - uniquetextiles + if UTT then + begin + aUTTCount[itab] := aFinalTileCount[itab]; + + for i := 0 to aUTTCount[itab] - 1 do + aUTTIndex[itab][i] := i + 1; + + with tbr.Maps do + for i := 0 to Length (aMaps) - 1 do + CreateUTTData (aMaps[i].map, tbr.Seq); + end; + + + + + + // asm nop end; + + end; + + + { + bmpFinal[itab].PixelFormat := pf24bit; + if N > 0 then + bmpFinal[itab].SaveToFile ('test' + IntToStr (itab) + '.bmp'); + if TexTiles then + if N > 0 then + bmpTexTiles[itab].SaveToFile ('tex' + IntToStr (itab) + '.bmp'); + } + + //// bmpFinal[itab].SaveToFile('bmpfinal' + chr(ord('1')+itab) + '.bmp'); + + + end; + end; + + + // generate the code + + ErrMsg := RunCode; + + // run cmd line if not empty and no errors + if (RunCMDLine <> '') AND (ErrMsg = '') then + begin + // StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); + StartProcess('cmd.exe', '/C ' + RunCMDLine, TRUE, FALSE); // execute, show window and wait? + end; + + + for itab := 0 to Tab.Tabs.Count - 1 do + with TileTab[itab].tbr do + begin + W := LastW; + H := LastH; + end; + +// CMDLINE_OP + if ReadParamCMD <> 'F10' then + begin + if ErrMsg <> '' then + ShowMessage (ErrMsg) + else + begin + with ProgressBar do + Position := Max; + ShowMessage ('Code generated successfully'); + end; + end; +// CMDLINE_OP + + // clean up and release memory + + SetLength (aFinalTinyTileCount, 0); + SetLength (aFinalTileCount, 0); + + for itab := 0 to Tab.Tabs.Count - 1 do + begin + SetLength (aFinalTinyTiles[itab][NOFLIP], 0); + SetLength (aFinalTinyTiles[itab][HFLIP], 0); + SetLength (aFinalTinyTiles[itab][VFLIP], 0); + SetLength (aFinalTinyTiles[itab][HVFLIP], 0); + + SetLength (aFinalTinyRef[itab], 0); + SetLength (aMCR[itab], 0); + SetLength (aFinalRef[itab], 0); + bmpFinal[itab].Free; + if aa then + bmpAlpha[itab].Free; + + // 2.4 + if TexTiles then + begin + if UTT then + SetLength (aUTTRef[itab], 0); + + SetLength (Corners[itab], 0); + SetLength (HEdges[itab], 0); + SetLength (VEdges[itab], 0); + bmpTexTiles[itab].Free; + if aa then + bmpTexAlpha[itab].Free; + end; + end; + + bmpCurTile.Free; // 2.54 + + + SetLength (aTransTile, 0); + + if TexTiles then + begin + if UTT then + begin + SetLength (aUTTRef, 0); + SetLength (aUTTIndex, 0); + SetLength (aUTTCount, 0); + end; + + SetLength (aCornerCount, 0); + SetLength (aHEdgeCount, 0); + SetLength (aVEdgeCount, 0); + SetLength (Corners, 0); + SetLength (HEdges, 0); + SetLength (VEdges, 0); + SetLength (aTrans, 0); + SetLength (aSameAs, 0); + SetLength (aMCRSur, 0); + SetLength (bmpTexTiles, 0); + SetLength (bmpTexAlpha, 0); + end; + + SetLength (aFinalTinyTiles, 0); + SetLength (aFinalTinyRef, 0); + SetLength (aFinalRef, 0); + SetLength (aMCR, 0 ); + + SetLength (bmpFinal, 0); + SetLength (bmpAlpha, 0); + + SetLength (TransX, 0); + SetLength (TransY, 0); + + bmp2.Width := W; + bmp2.Height := H; + ResizeBitmap (bmp2); + bmp1.Width := W; + bmp1.Height := H; + ResizeBitmap (bmp1); + + ProgressPanel.Visible := FALSE; + Modified := TRUE; + +end; + +procedure TMainForm.CodeGenerationSettings1Click(Sender: TObject); + var + s: string; +begin + s := CodeGen.LastDef; + CodeGen.ProjectDir := FilePath (FileName); + CodeGen.ShowModal; + if CodeGen.LastDef <> s then + Modified := TRUE; +end; + + +procedure TMainForm.SelectOutputDirectory1Click(Sender: TObject); + var + f, s: string; + rel: Boolean; +begin + + f := FileName; + if f <> '' then + while (Pos ('\', f) > 0) and (f[Length (f)] <> '\') do + Delete (f, Length (f), 1); + + s := OutputPath; + if (s <> '') and (s[Length (s)] = '\') then + Delete (s, Length (s), 1); + Rel := True; + if s <> '' then + begin + s := s + '\'; + if s[1] = '\' then + Rel := FALSE; + if (Length (s) >= 3) and (s[2] = ':') then + Rel := FALSE; + end; + if Rel then + if f <> '' then + s := f + s; + + try + OutputDir.DirectoryListBox.Directory := s; + except + OutputPath := ''; + OutputDir.DirectoryListBox.Directory := ''; + end; + + OutputDir.ShowModal; + if OutputDir.Result then + begin + s := OutputDir.DirectoryListBox.Directory; + + if Copy (s, 1, Length (f)) = f then + Delete (s, 1, Length (f)); + + OutputPath := s; + if OutputPath <> '' then + if OutputPath[Length (OutputPath)] <> '\' then + OutputPath := OutputPath + '\'; + Modified := TRUE; + + SelectOutputDirectory1.Checked := TRUE; + OutputtoProjectDirectory1.Checked := FALSE; + end; +end; + +procedure TMainForm.ReplaceColors1Click(Sender: TObject); + var + i, j, k, l, m, n, o: Integer; + r, g, b, rr, gg, bb, r1, g1, b1, r2, g2, b2: Integer; + c: Integer; + + function verh (m1, m2, m, n1, n2: Integer): Integer; + begin + if m1 = m2 then + verh := n1 + else + verh := n1 + (n2 - n1) * (m - m1) div (m2 - m1); + end; + +begin + GetTileArea; + + // 2.54 - update: use current color pattern + if SplitColorPattern1.Checked then + with Bmp.Canvas do + begin + SaveUndo ('Replace Colors'); + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + begin + c := Pixels[TileAreaX + i, TileAreaY + j]; + if c <> TRANS_COLOR then + begin + + for k := FromToFirst to FromToLast do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + for k := FromToLast downto FromToFirst do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + + c := ColorMatch (c); + + for k := FromToFirst to FromToLast do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + for k := FromToLast downto FromToFirst do + if c = OtherFromTo.FT[k] then + c := FromToList[k]; + + Pixels[TileAreaX + i, TileAreaY + j] := c; + end; + end; + + AddColorPattern1Click(Sender); + UpdateBmp (TRUE); + Modified := TRUE; + Exit; + end; + + m := -1; + n := 0; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + with Bmp.Canvas do + begin + o := 0; + c := Pixels[TileAreaX + i, TileAreaY + j]; + if c <> TRANS_COLOR then + begin + c := ColorMatch (c); + for k := 0 to Length (FromToSave) - 1 do + for l := 0 to MAX_FROM_TO - 1 do + if c = FromToSave[k].FT[l] then + begin + Inc (o); + if o > n then + begin + m := k; + n := o; + end; + end; + end; + end; + if m < 0 then + Exit; + SaveUndo ('Replace Colors'); + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + with Bmp.Canvas do + begin + // o := 0; + c := Pixels[TileAreaX + i, TileAreaY + j]; + if c <> TRANS_COLOR then + begin + { + c := ColorMatch (c); + for l := 0 to MAX_FROM_TO - 1 do + if c = FromToSave[m].FT[l] then + begin + Pixels[BORDER_W + i, BORDER_H + j] := FromToList[l]; + Inc (o); + end; + if o = 0 then } + begin + GetRGB (c, R, G, B); + + r1 := 0; + g1 := 0; + b1 := 0; + for l := 0 to MAX_FROM_TO - 1 do + begin + GetRGB (FromToSave[m].FT[l], rr, gg, bb); + if rr <= r then + r1 := l; + if gg <= g then + g1 := l; + if bb <= b then + b1 := l; + end; + + r2 := MAX_FROM_TO - 1; + g2 := MAX_FROM_TO - 1; + b2 := MAX_FROM_TO - 1; + for l := MAX_FROM_TO - 1 downto 0 do + begin + GetRGB (FromToSave[m].FT[l], rr, gg, bb); + if rr >= r then + r2 := l; + if gg >= g then + g2 := l; + if bb >= b then + b2 := l; + end; + + r := verh (FromToSave[m].EXFT[r1, 0], + FromToSave[m].EXFT[r2, 0], + r, + ExFromToList[r1, 0], + ExFromToList[r2, 0]); + g := verh (FromToSave[m].EXFT[g1, 1], + FromToSave[m].EXFT[g2, 1], + g, + ExFromToList[g1, 1], + ExFromToList[g2, 1]); + b := verh (FromToSave[m].EXFT[b1, 2], + FromToSave[m].EXFT[b2, 2], + b, + ExFromToList[b1, 2], + ExFromToList[b2, 2]); + r := LimitRGB (r); + g := LimitRGB (g); + b := LimitRGB (b); + + r := ColorMatch (r); + g := ColorMatch (g); + b := ColorMatch (b); + + Pixels[TileAreaX + i, TileAreaY + j] := ColorMatch (RGB (r, g, b)); + end; + end; + end; + + AddColorPattern1Click(Sender); + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.MapScrollFunction1Click(Sender: TObject); +begin + if MapTab.TabIndex > -1 then + with TileTab[Tab.TabIndex].tbr.Maps do + begin + with aMaps[CurMap] do + begin + if fx = '' then + MapScroll.X.Text := 'x' + else + MapScroll.X.Text := fx; + if fy = '' then + MapScroll.Y.Text := 'y' + else + MapScroll.Y.Text := fy; + end; + MapScroll.ShowModal; + if MapScroll.Result then + begin + aMaps[CurMap].fx := MapScroll.X.Text; + aMaps[CurMap].fy := MapScroll.Y.Text; + Modified := TRUE; + end; + end; +end; + +function BlackWhite (rgb: Integer): Integer; + var + R, G, B: Integer; +begin + GetRGB (rgb, R, G, B); + if R + G + B >= 3 * 128 then + BlackWhite := clWhite + else + BlackWhite := clBlack; +end; + +procedure TMainForm.SaveCurrentTile1Click(Sender: TObject); + var + bmpTemp: TBitmap; + i, j, c: Integer; + { Mono: Boolean; } +begin + SavePictureDialog.DefaultExt := GraphicExtension(TBitmap); + if SavePictureDialog.Execute then + begin + bmpTemp := TBitmap.Create; + SetStretchBltMode(bmpTemp.Canvas.Handle, HALFTONE); +// bmpTemp.PixelFormat := pf16bit; +// bmpTemp.Canvas.CopyRect (Rect (0, 0, W, H), +// bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + { Mono := FALSE; } + case SavePictureDialog.FilterIndex of + 1: bmpTemp.PixelFormat := pf24bit; + 2: bmpTemp.PixelFormat := pf16bit; + 3: bmpTemp.PixelFormat := pf15bit; + 4: bmpTemp.PixelFormat := pf8bit; + 5: bmpTemp.PixelFormat := pf4bit; + 6: begin + bmpTemp.PixelFormat := pf1bit; + { Mono := TRUE; } + end; + 7: bmpTemp.PixelFormat := pf24bit; // PNG + end; + bmpTemp.Width := W; + bmpTemp.Height := H; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + begin + c := bmp.Canvas.Pixels[i + BORDER_W, j + BORDER_H]; + { + if Mono then + bmpTemp.Canvas.Pixels[i, j] := BlackWhite (c) + else + } + bmpTemp.Canvas.Pixels[i, j] := c; + end; + if UpperCase (ExtractFileExt (SavePictureDialog.Filename)) = '.PNG' then + begin + bmpTemp.TransparentColor := TRANS_COLOR; + WriteBitmapToPngFile (SavePictureDialog.Filename, bmpTemp, TRANS_COLOR); + end + else + bmpTemp.SaveToFile (SavePictureDialog.FileName); + bmpTemp.Free; + end; +end; + +{$IFNDEF IMPORTEDLEV} +procedure TMainForm.ImportEdlevClick(Sender: TObject); +begin + ShowMessage ('Not implemented in this version.'); +end; +{$ELSE} +procedure TMainForm.ImportEdlevClick(Sender: TObject); + var + i: Integer; + dir: string; +begin +{ + SetEditorMode (mTile); + ImportLevelTiles ('d:\dos\old\ch3\', 'MainChar', 40, 48, 'c'); + + SetEditorMode (mTile); + ImportLevelTiles ('d:\dos\old\ch3\', 'W1', 32, 24); + SetEditorMode (mMap); + ImportLevelMap ('d:\dos\old\ch3\', 'L1', 'L1'); +} + +{ + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W1', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'TITLE', 'Title'); + + ImportLevelMap ('c:\ch2\', 'P1', 'T1'); + ImportLevelMap ('c:\ch2\', 'P1B', 'T1B'); + + ImportLevelMap ('c:\ch2\', 'L1', 'L1'); + ImportLevelMap ('c:\ch2\', 'L1B', 'L1B'); + ImportLevelMap ('c:\ch2\', 'L2', 'L2'); + ImportLevelMap ('c:\ch2\', 'L3', 'L3'); + ImportLevelMap ('c:\ch2\', 'L3B', 'L3B'); + ImportLevelMap ('c:\ch2\', 'L4', 'L4'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W2', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'L5', 'L5'); + ImportLevelMap ('c:\ch2\', 'L5B', 'L5B'); + ImportLevelMap ('c:\ch2\', 'L6', 'L6'); + ImportLevelMap ('c:\ch2\', 'L7', 'L7'); + ImportLevelMap ('c:\ch2\', 'L7B', 'L7B'); + ImportLevelMap ('c:\ch2\', 'L8', 'L8'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W3', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'L9', 'L9'); + ImportLevelMap ('c:\ch2\', 'L9B', 'L9B'); + ImportLevelMap ('c:\ch2\', 'LA', 'LA'); + ImportLevelMap ('c:\ch2\', 'LB', 'LB'); + ImportLevelMap ('c:\ch2\', 'LBB', 'LBB'); + ImportLevelMap ('c:\ch2\', 'LC', 'LC'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W4', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'X1', 'X1'); + ImportLevelMap ('c:\ch2\', 'X1B', 'X1B'); + ImportLevelMap ('c:\ch2\', 'X2', 'X2'); + ImportLevelMap ('c:\ch2\', 'X3', 'X3'); + ImportLevelMap ('c:\ch2\', 'X3B', 'X3B'); + ImportLevelMap ('c:\ch2\', 'X4', 'X4'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W5', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'X5', 'X5'); + ImportLevelMap ('c:\ch2\', 'X5B', 'X5B'); + ImportLevelMap ('c:\ch2\', 'X6', 'X6'); + ImportLevelMap ('c:\ch2\', 'X7', 'X7'); + ImportLevelMap ('c:\ch2\', 'X7B', 'X7B'); + ImportLevelMap ('c:\ch2\', 'X8', 'X8'); + + SetEditorMode (mTile); + ImportLevelTiles ('c:\ch2\', 'W6', 20, 14); + SetEditorMode (mMap); + ImportLevelMap ('c:\ch2\', 'X9', 'X9'); + ImportLevelMap ('c:\ch2\', 'X9B', 'X9B'); + ImportLevelMap ('c:\ch2\', 'XA', 'XA'); + ImportLevelMap ('c:\ch2\', 'XB', 'XB'); + ImportLevelMap ('c:\ch2\', 'XBB', 'XBB'); + ImportLevelMap ('c:\ch2\', 'XC', 'XC'); + + ImportLevelTiles ('c:\ch2\', 'MainChar', 20, 28, 'c'); + + ImportLevelTiles ('c:\ch2\', 's20x28', 20, 28, 's'); + ImportLevelTiles ('c:\ch2\', 's20x16', 20, 16, 's'); + ImportLevelTiles ('c:\ch2\', 's24x14', 20, 14, 's'); + ImportLevelTiles ('c:\ch2\', 's24x14', 24, 14, 's'); + ImportLevelTiles ('c:\ch2\', 's8x7', 8, 7, 's'); + ImportLevelTiles ('c:\ch2\', 's8x8', 8, 8, 's'); + ImportLevelTiles ('c:\ch2\', 's40x28', 40, 28, 's'); + ImportLevelTiles ('c:\ch2\', 's40x6', 40, 6, 's'); + ImportLevelTiles ('c:\ch2\', 's20x6', 20, 6, 's'); + ImportLevelTiles ('c:\ch2\', 's32x28', 32, 28, 's'); + ImportLevelTiles ('c:\ch2\', 's10x14', 10, 14, 's'); + ImportLevelTiles ('c:\ch2\', 's20x18', 20, 18, 's'); + ImportLevelTiles ('c:\ch2\', 's40x24', 40, 24, 's'); + ImportLevelTiles ('c:\ch2\', 's32x24', 32, 24, 's'); + ImportLevelTiles ('c:\ch2\', 's20x24', 20, 24, 's'); + ImportLevelTiles ('c:\ch2\', 's12x8', 12, 8, 's'); + ImportLevelTiles ('c:\ch2\', 's12x7', 12, 7, 's'); + ImportLevelTiles ('c:\ch2\', 's26x16', 26, 16, 's'); + ImportLevelTiles ('c:\ch2\', 's32x18', 32, 18, 's'); +} + + for i := 0 to Tab.Tabs.Count - 1 do + begin + Tab.TabIndex := i; + TabChange (nil); + RemoveDuplicateTiles1Click(nil); + end; +end; + +procedure TMainForm.ImportAnySize (dir: string; extc: Char); + var + F: file of Byte; + SR: TSearchRec; + Wd, Ht: Byte; + ai: array of Integer; + i: Integer; + L: Integer; + Found: Boolean; +begin + SetLength (ai, 0); + if FindFirst (dir + '*.' + extc + '??', faAnyFile, SR) = 0 then + repeat + AssignFile (F, dir + SR.Name); + Reset (F); + if FileSize (F) <= 64 * 64 then + begin + BlockRead (F, Wd, SizeOf (Wd)); + BlockRead (F, Ht, SizeOf (Ht)); + if (Wd <= 64) and (Ht <= 64) and (FileSize (F) = Wd * Ht + 2 * SizeOf (Byte)) then + begin + L := Length (ai); + Found := FALSE; + for i := 0 to L - 1 do + if ai[i] = (Ht shl 8) + Wd then + Found := TRUE; + if not Found then + begin + SetLength (ai, L + 1); + ai[L] := (Ht shl 8) + Wd; + end; + end; + end; + CloseFile (F); + until FindNext (SR) <> 0; + FindClose (SR); + + for i := 0 to Length (ai) - 1 do + begin + Wd := ai[i] and $FF; + Ht := (ai[i] shr 8) and $FF; + ImportLevelTiles (dir, 's' + IntToStr (Wd) + 'x' + IntToStr (Ht), Wd, Ht, extc); + end; + + SetLength (ai, 0); +end; + +procedure TMainForm.ImportLevelTiles (dir, name: string; ww, hh: Integer; extc: Char); + var + TB: TBitmap; + FT: TextFile; + F: file; + s: string; + Pal: array[0..255, 0..2] of Byte; + ai: array of Integer; + TmpBmpName: string; + i, j: Integer; + SR: TSearchRec; + + procedure ReadTile (filename: string); + var + i, j, k: Integer; + Wd, Ht: Byte; + b: Byte; + begin + AssignFile (F, filename); + Reset (F, 1); + BlockRead (F, Wd, SizeOf (Wd)); + BlockRead (F, Ht, SizeOf (Ht)); + TB.Height := TB.Height + hh; + if (Wd = ww) and (Ht = hh) then + begin + for j := 0 to Ht - 1 do + for i := 0 to Wd - 1 do + begin + BlockRead (F, b, SizeOf (b)); + if b = 0 then + k := TRANS_COLOR + else + k := RGB (Pal[b, 0], Pal[b, 1], Pal[b, 2]); + TB.Canvas.Pixels[i, TB.Height - hh + j] := k; + end; + end; + CloseFile (F); + end; + +begin + TmpBmpName := '$tmp$bmp$.bmp'; + + TB := TBitmap.Create; + SetStretchBltMode(TB.Canvas.Handle, HALFTONE); + TB.PixelFormat := pf24bit; + TB.Width := ww; + + SetLength (ai, 2); + ai[0] := TRANS_COLOR; + ai[1] := TRANS_COLOR; + + AssignFile (F, dir + 'DEFAULT.PAL'); + Reset (F, 1); + BlockRead (F, Pal, SizeOf (Pal)); + CloseFile (F); + for i := 0 to 255 do + for j := 0 to 2 do + Pal[i, j] := Pal[i, j] shl 2; + + if (extc = #0) and FileExists (dir + 'NUMBERS.EDL') then + begin + AssignFile (FT, dir + 'NUMBERS.EDL'); + Reset (FT); + repeat + ReadLn (FT, s); + if FileExists (dir + s) then + ReadTile (dir + s); + until Eof (FT) or (s = ''); + CloseFile (FT); + end + else + begin + if FindFirst (dir + '*.' + extc + '??', faAnyFile, SR) = 0 then + repeat + ReadTile (dir + SR.Name); + + until FindNext (SR) <> 0; + FindClose (SR); + end; + + TB.SaveToFile (TmpBmpName); + TB.Free; + + CreateNewTileCollection (name, ww, hh, TRUE); + FreeTBR (TileTab[Tab.TabIndex].tbr); + MainForm.ProgressPanel.Visible := TRUE; + TileTab[Tab.TabIndex].tbr := + ReadTileBitmap (TmpBmpName, + ww, hh, 0, 0, + ai, 0, 0, 0, 0, + ProgressBar, + FALSE, + FALSE, + FALSE, + TileTab[Tab.TabIndex].tbr); + + SetLength (ai, 0); + MainForm.ProgressPanel.Visible := FALSE; + + TabChange (nil); + Modified := TRUE; +end; + +procedure TMainForm.ImportLevelMap (dir, filename, name: string); + type + MapDataRec = + record + BGNr, + FGNr: Word; + BGAdd, + FGAdd, + Bound, + Code: Byte; + end; + ReplaceRec = + record + OldNr: Word; + Add: Byte; + NewNr: Word; + end; + var + F: file; + sig: array[0..3] of Char; + HSize, VSize: SmallInt; + ww, hh: SmallInt; + mdr: MapDataRec; + i, j, k, x, y: Integer; + repl: array of ReplaceRec; + SeqNr: Integer; + + function GetAddTile (N: Word; Add: Byte): Word; + var + F: file; + FT: TextFile; + s: string; + Pal: array[0..255, 0..2] of Byte; + i, j, k: Integer; + Wd, Ht: Byte; + b: Byte; + begin + for i := 0 to Length (repl) - 1 do + if (repl[i].OldNr = N) and (repl[i].Add = Add) then + begin + GetAddTile := repl[i].NewNr; + Exit; + end; + + CreateNewTile (TileTab[Tab.TabIndex].tbr); + + AssignFile (F, dir + 'DEFAULT.PAL'); + Reset (F, 1); + BlockRead (F, Pal, SizeOf (Pal)); + CloseFile (F); + for i := 0 to 255 do + for j := 0 to 2 do + Pal[i, j] := Pal[i, j] shl 2; + + AssignFile (FT, dir + 'NUMBERS.EDL'); + Reset (FT); + for k := 1 to N - 1 do + ReadLn (FT); + ReadLn (FT, s); + if FileExists (dir + s) then + begin + AssignFile (F, dir + s); + Reset (F, 1); + BlockRead (F, Wd, SizeOf (Wd)); + BlockRead (F, Ht, SizeOf (Ht)); + if (Wd = W) and (Ht = H) then + begin + for j := 0 to Ht - 1 do + for i := 0 to Wd - 1 do + begin + BlockRead (F, b, SizeOf (b)); + if b = 0 then + k := TRANS_COLOR + else + begin + b := (b + Add) mod 256; + k := RGB (Pal[b, 0], Pal[b, 1], Pal[b, 2]); + end; + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := k; + end; + end; + CloseFile (F); + end; + CloseFile (FT); + + i := Length (repl); + SetLength (repl, i + 1); + repl[i].OldNr := N; + repl[i].Add := Add; + repl[i].NewNr := TileTab[Tab.TabIndex].tbr.TileCount - 1; + + //UpdateBmp (TRUE); + + with TileTab[Tab.TabIndex] do + tbr.TileBitmap.Canvas.CopyRect (MakeRect (tbr.Current * W, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + + + UpdateTileBitmap; + GetAddTile := TileTab[Tab.TabIndex].tbr.TileCount - 1; + end; + + function CmpMCR (mcr1, mcr2: MapCellRec): Boolean; + begin + CmpMCR := (mcr1.Back = mcr2.Back) and (mcr1.Mid = mcr2.Mid) and + (mcr1.Front = mcr2.Front) and (mcr1.Bounds = mcr2.Bounds); + end; + +begin { ImportLevelMap } + SetEditorMode (mMap); + + HSize := 0; + VSize := 0; + SetLength (repl, 0); + AssignFile (F, dir + filename); + Reset (F, 1); + + BlockRead (F, sig, SizeOf (sig)); + +// if (sig[0] = 'M') and (sig[1] = 'A') and (sig[2] = 'P') then + begin + if (sig[0] = 'M') and (sig[1] = 'A') and (sig[2] = 'P') then + begin + BlockRead (F, HSize, SizeOf (HSize)); + BlockRead (F, VSize, SizeOf (VSize)); + BlockRead (F, ww, SizeOf (ww)); + BlockRead (F, hh, SizeOf (hh)); + end + else + begin + CloseFile (F); + + AssignFile (F, dir + filename); + Reset (F, 1); + BlockRead (F, HSize, SizeOf (HSize)); + BlockRead (F, VSize, SizeOf (VSize)); + ww := W; + hh := H; + end; + + if (ww = W) and (hh = H) then + begin + NewMap (TileTab[Tab.TabIndex].tbr, name, HSize, VSize); + + MapTab.TabIndex := MapTab.Tabs.Add (name); + MapTabChange (nil); + + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + for j := 0 to VSize - 1 do + for i := 0 to HSize - 1 do + begin + BlockRead (F, mdr, SizeOf (mdr)); + + with Map[j, i], mdr do + begin + if FGNr and $FFF <> 0 then + begin + if FGAdd <> 0 then + FGNr := (FGNr and $F000) + (GetAddTile (FGNr and $FFF, FGAdd) + 1); + Mid := SmallInt ((FGNr and $CFFF) - 1); + end; + if BGNr and $FFF <> 0 then + begin + if BGAdd <> 0 then + BGNr := (BGNr and $F000) + (GetAddTile (BGNr and $FFF, BGAdd) + 1); + if BGNr and $2000 = $2000 then + Front := SmallInt ((BGNr and $CFFF) - 1) + else + Back := SmallInt ((BGNr and $CFFF) - 1); + end; + + Bounds := ShortInt (Bound); + MapCode := Code; + end; + + end; + end; + + end; + end; + CloseFile (F); + Modified := TRUE; + SetLength (repl, 0); + + SetEditorMode (mMap); + + // sequences: + i := 0; + SeqNr := SeqTab.Tabs.Count; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + while (i < HSize - 1) and (Map[0, i].MapCode = $FF) do + begin + j := 0; + while (j < VSize - 1) and (Map[j, i].MapCode = $FF) + and (not EmptyMCR (Map[j + 1, i])) do + begin + Area.Top := j + 1; + Area.Left := i; + Area.Bottom := j + 1; + Area.Right := i; + + k := j + 1; + while (k <= VSize - 1) and (Map[k, i].MapCode <> $FF) and + (not EmptyMCR (Map[k, i])) do + Inc (k); + if k <= VSize - 1 then + begin + for y := 0 to VSize - 1 do + for x := i + 1 to HSize - 1 do + if CmpMCR (Map[y, x], Map[Area.Top, Area.Left]) then + with Map[y, x] do + begin + // Bounds := $FF; + // Bounds := ShortInt ($80); + Bounds := $40; + Back := -1; + Mid := -1; + Front := -1; + MapCode := SeqNr; + end; + + Area.Bottom := k - 1; + Selection := TRUE; + ConverttoTileSequence1Click (nil); + Inc (SeqNr); + Selection := FALSE; + end; + j := k; + end; + Inc (i); + end; + + // remove first columns + if i > 0 then + for y := 0 to VSize - 1 do + begin + for x := i to HSize - 1 do + Map[y, x - i] := Map[y, x]; + SetLength (Map[y], Length (Map[y]) - i); + end; + end; + + SetEditorMode (mTile); +end; +{$ENDIF} + +procedure TMainForm.InsertHorizontal1Click(Sender: TObject); + var + InsPos, InsCount: Integer; + MapH, i, j: Integer; +begin + InsPos := 0; + InsCount := 1; + if Selection then + begin + InsPos := Area.Left; + InsCount := Area.Right - Area.Left + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapH := Length (Map); + for j := 0 to MapH - 1 do + begin + SetLength (Map[j], Length (Map[j]) + InsCount); + for i := Length (Map[j]) - 1 downto InsPos + InsCount do + Map[j, i] := Map[j, i - InsCount]; +// for i := 0 to InsCount - 1 do +// ClearMCR (Map[j, InsPos + i]); + end; + end; + Area := Rect (InsPos, 0, InsPos + InsCount - 1, MapH - 1); + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.DeleteHorizontal1Click(Sender: TObject); + var + DelPos, DelCount: Integer; + MapH, i, j: Integer; +begin + DelPos := 0; + DelCount := 1; + if Selection then + begin + DelPos := Area.Left; + DelCount := Area.Right - Area.Left + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapH := Length (Map); + for j := 0 to MapH - 1 do + begin + for i := DelPos + DelCount to Length (Map[j]) - 1 do + Map[j, i - DelCount] := Map[j, i]; + i := Length (Map[j]) - DelCount; + if i < 0 then i := 0; + SetLength (Map[j], i); + end; + end; + Selection := FALSE; + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.InsertVertical1Click(Sender: TObject); + var + InsPos, InsCount: Integer; + MapW, i, j: Integer; +begin + InsPos := 0; + InsCount := 1; + if Selection then + begin + InsPos := Area.Top; + InsCount := Area.Bottom - Area.Top + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapW := 0; + if Length (Map) > 0 then + MapW := Length (Map[0]); + SetLength (Map, Length (Map) + InsCount); + for j := 0 to InsCount - 1 do + SetLength (Map[Length (Map) - 1 - j], MapW); + for j := Length (Map) - 1 downto InsPos + InsCount do + for i := 0 to MapW - 1 do + Map[j, i] := Map[j - InsCount, i]; + end; + { RD: clear selection and redraw map with new dimensions } + Area := Rect (0, InsPos, MapW - 1, InsPos + InsCount - 1); + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.DeleteVertical1Click(Sender: TObject); + var + DelPos, DelCount: Integer; + MapW, i, j: Integer; +begin + DelPos := 0; + DelCount := 1; + if Selection then + begin + DelPos := Area.Top; + DelCount := Area.Bottom - Area.Top + 1; + end; + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + begin + MapW := 0; + if Length (Map) > 0 then + MapW := Length (Map[0]); + for j := DelPos + DelCount to Length (Map) - 1 do + for i := 0 to MapW - 1 do + Map[j - DelCount, i] := Map[j, i]; + for j := 0 to DelCount - 1 do + SetLength (Map[Length (Map) - 1 - j], MapW); + SetLength (Map, Length (Map) - DelCount); + end; + Selection := FALSE; + UpdateMap; + Modified := TRUE; +end; + +procedure TMainForm.FormShow(Sender: TObject); +begin + if ReadParamFile then + begin + Modified := FALSE; + Open1Click (nil); + //CMDLINE_OP + ReadParamFile := ParamCount > 1; + if ReadParamFile then + begin + + + ReadParamCMD := ParamStr(2); + + if ReadParamCMD = 'F10' then + begin + Generate1Click(Self); + Modified := FALSE; + Exit1Click(Self); + end; + end; + //CMDLINE_OP + end; + ReadParamFile := FALSE; +end; + +procedure TMainForm.Tutorial1Click(Sender: TObject); + var + Param: string; +begin + Param := ApplPath + 'Tutorial\tutor.html'; + ShellExecute (0, 'open', PChar (Param), Nil, Nil, SW_SHOWNORMAL); +end; + +procedure TMainForm.OutputtoProjectDirectory1Click(Sender: TObject); +begin + SelectOutputDirectory1.Checked := FALSE; + OutputtoProjectDirectory1.Checked := TRUE; + OutputPath := FilePath (FileName); +end; + +procedure TMainForm.RecentFileClick (Sender: TObject); +begin + with Sender as TMenuItem do + begin + ReadParamFile := TRUE; + FileToOpen := RecentFiles.Strings[Tag]; + Open1Click (Nil); + ReadParamFile := FALSE; + end; +end; + +procedure TMainForm.AddFileToRecentProjects (FileName: string); + var + i: Integer; +begin + RecentFiles.Insert (0, FileName); + for i := 1 to RecentFiles.Count - 1 do + if i <= RecentFiles.Count - 1 then + if UpCaseStr (RecentFiles.Strings[i]) = UpCaseStr (FileName) then + RecentFiles.Delete (i); + UpdateRecentFilesMenu; +end; + +procedure TMainForm.ReadConfigFile; + var + F: TextFile; + s: string; + + procedure ReadRecentFiles; + var + s: string; + begin + ReadLn (F, s); + while (not Eof (F)) and (s <> '') do + begin + RecentFiles.Append (s); + ReadLn (F, s); + end; + end; + + procedure ReadWindowState; + var + s: string; + C: Char; + Error: Boolean; + V, Code: Integer; + begin + Error := FALSE; + ReadLn (F, s); + repeat + if (Length (s) > 2) and (s[2] = '=') then + begin + C := s[1]; + Delete (s, 1, 2); + Val (s, V, Code); + if Code <> 0 then + Error := TRUE + else + case C of + 'X': WinLeft := V; + 'Y': WinTop := V; + 'W': WinWidth := V; + 'H': WinHeight := V; + end; + end; + + if not Error then + ReadLn (F, s); + until Eof (F) or (s = '') or Error; + end; + + procedure ReadSettings; + var + s, Name: string; + Error: Boolean; + V, Code: Integer; + begin + Error := FALSE; + ReadLn (F, s); + repeat + if (Pos ('=', s) > 0) then + begin + Name := Copy (s, 1, Pos ('=', s) - 1); + Delete (s, 1, Pos ('=', s)); + Val (s, V, Code); + if Code <> 0 then + Error := TRUE + else + begin + if Name = 'Trans' then TRANS_COLOR := V; + if Name = 'Replace' then TRANS_COLOR_REPLACEMENT := V; + end; + end; + + if not Error then + ReadLn (F, s); + until Eof (F) or (s = '') or Error; + end; + +begin { ReadConfigFile } + WinWidth := 800; + WinHeight := 600; + + if FileExists (ApplPath + CONFIG_FILE) then // bugfix 2.55 + begin + AssignFile (F, ApplPath + CONFIG_FILE); + Reset (F); + ReadLn (F, s); + if s = UpCaseStr (APPL_NAME) then + begin + + repeat + ReadLn (F, s); + if s = '[Recent Projects]' then + ReadRecentFiles; + if s = '[Window]' then + ReadWindowState; + if s = '[Settings]' then + ReadSettings; + until Eof (F); + + end; + CloseFile (F); + end; +end; + +procedure TMainForm.WriteConfigFile; + var + F: TextFile; + i: Integer; + R, G, B: Integer; +begin + if CDROM then { bug fix 2.43 } + Exit; + + AssignFile (F, ApplPath + CONFIG_FILE); + ReWrite (F); + WriteLn (F, UpCaseStr (APPL_NAME)); + WriteLn (F); + + WriteLn (F, '[Recent Projects]'); + for i := 0 to RecentFiles.Count - 1 do + WriteLn (F, RecentFiles.Strings[i]); + WriteLn (F); + + WriteLn (F, '[Window]'); + WriteLn (F, 'X=', MainForm.Left); + WriteLn (F, 'Y=', MainForm.Top); + WriteLn (F, 'W=', MainForm.Width); + WriteLn (F, 'H=', MainForm.Height); + WriteLn (F); + + WriteLn (F, '[Settings]'); + GetRGB (TRANS_COLOR, R, G, B); + WriteLn (F, 'Trans=$', Hex2 (R and $FF), Hex2 (G and $FF), Hex2 (B and $FF)); + GetRGB (TRANS_COLOR_REPLACEMENT, R, G, B); + WriteLn (F, 'Replace=$', Hex2 (R and $FF), Hex2 (G and $FF), Hex2 (B and $FF)); + WriteLn (F); + + CloseFile (F); +end; + +procedure TMainForm.SmoothPalette1Click(Sender: TObject); +begin + with SmoothPalette1 do + begin + Checked := not Checked; + RearrangePalette1.Enabled := not Checked; + end; + Palette.Repaint; +end; + +procedure TMainForm.PaletteManager1Click(Sender: TObject); + var + i: Integer; + + function FindOrig (n: Integer): Integer; + var + j: Integer; + begin + FindOrig := -1; + for j := 0 to Length (aiOrig) - 1 do + if aiOrig[j] = n then + FindOrig := j; + end; + +begin + with TileTab[Tab.TabIndex].tbr do // bug fix 2.34 + SelectedPalette := PaletteNumber; + + DefaultPaletteChanged := FALSE; + SelectedPaletteChanged := FALSE; + + // store numbers in case some palettes are deleted + SetLength (aiOrig, Length (aaiPal)); + for i := 0 to Length (aaiPal) - 1 do + aiOrig[i] := i; + + SetLength (aiUsedColors, 0); + if ShowUsedColors1.Checked then + with UsedColorsImage.Picture.Bitmap do + if Height - 1 <= 256 then + begin + SetLength (aiUsedColors, Height - 1); + for i := 0 to (Height - 1) - 1 do + aiUsedColors[i] := Canvas.Pixels[0, i + 1]; + end; + + PaletteManager.ShowModal; + + for i := 0 to Tab.Tabs.Count - 1 do + with TileTab[i].tbr do + if PaletteNumber <> -1 then + PaletteNumber := FindOrig (PaletteNumber); + + if DefaultPaletteChanged then + if DefaultPalette <> -1 then + begin + for i := 0 to Tab.Tabs.Count - 1 do + with TileTab[i].tbr do + if PaletteNumber = -1 then + PaletteNumber := DefaultPalette; + end; + + if SelectedPaletteChanged then + with TileTab[Tab.TabIndex].tbr do + PaletteNumber := SelectedPalette; + + if ShowCurrentPalette1.Checked then + begin + ShowCurrentPalette1.Checked := FALSE; + ShowCurrentPalette1Click (Sender); + end; +end; + + +// new 2.0 - move entire animation +procedure TMainForm.ImportPovRayanimation1Click(Sender: TObject); +begin + if not HasNoTiles (TileTab[Tab.TabIndex].tbr) then + if MessageDlg ('Current Tile Set will be overwritten by imported tiles.', + mtWarning, [mbOk, mbCancel], 0) <> mrOk then + Exit; + ImpPovAni.CurTileW := W; + ImpPovAni.CurTileH := H; + PovAni.ShowModal; + if ImpPovAni.Done then + begin + TabChange (Sender); + Modified := TRUE; + UpdateTileBitmap; + end; +end; + +procedure TMainForm.Up2Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Up1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.Down2Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Down1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.Left3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Left1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.Right3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + begin + Current := 0; + repeat + Right1Click (Sender); + NextTile1Click (Sender); + until Current + 1 >= TileCount; + end; + StartEdit (FALSE); +end; + +procedure TMainForm.NoDelay1Click(Sender: TObject); +begin + if AnimationTimer.Enabled then + AnimationTimer.Interval := 1; +end; + +procedure TMainForm.ShowCurrentPalette1Click(Sender: TObject); + var + bmp: TBitmap; + i, p: Integer; +begin + UsedColors.ShowHint := TRUE; + with TileTab[Tab.TabIndex] do + p := tbr.PaletteNumber; + if p = -1 then + p := DefaultPalette; + with ShowCurrentPalette1 do + begin + Checked := not Checked; + if Checked then + begin + if p = -1 then + Msg ('No palette selected for this tile set and no default palette available.') + else + if aiPreset[p] = 0 then + Msg ('The selected palette is empty.') + else + begin + bmp := TBitmap.Create; + SetStretchBltMode(bmp.Canvas.Handle, HALFTONE); + with bmp do + begin + PixelFormat := pf24bit; + Width := 1; + Height := aiPreset[p]; + for i := 0 to aiPreset[p] - 1 do + Canvas.Pixels[0, i] := aaiPal[p, i]; + end; + UsedColorsImage.Picture.Bitmap := bmp; + bmp.Free; + UsedColorsImage.Stretch := TRUE; + UsedColors.Visible := TRUE; + MainForm.Resize; + end; + end + else + HideUsedColors; + end; + UsedColorSelect := FALSE; +end; + +procedure TMainForm.ImportMap1Click(Sender: TObject); + var + F: file of Byte; + i1: Byte; + i2: SmallInt; + i4, L: LongInt; + b4: array [0..3] of Byte; + MapX, MapY, MapW, MapH, N: Integer; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + if ImportMapDialog.Execute then + begin + MapX := 0; + MapY := 0; + MapW := Length (Map[0]); + MapH := Length (Map); + if Selection then + begin + MapX := Area.Left; + MapY := Area.Top; + MapW := Area.Right - Area.Left + 1; + MapH := Area.Bottom - Area.Top + 1; + end; + if MapW = 0 then + Exit; + AssignFile (F, ImportMapDialog.Filename); + try + Reset (F); + N := 0; + L := 0; + repeat + case (ImportMapDialog.FilterIndex - 1) div 2 of + 0: begin + Read (F, i1); + L := i1; + end; + 1: begin + Read (F, b4[0]); + Read (F, b4[1]); + Move (b4, i2, SizeOf (i2)); + L := i2; + end; + 2: begin + Read (F, b4[0]); + Read (F, b4[1]); + Read (F, b4[2]); + Read (F, b4[3]); + Move (b4, i4, SizeOf (i4)); + L := i4; + end; + end; + if (ImportMapDialog.FilterIndex - 1) mod 2 = 1 then + Dec (L); + if (L < 0) or (L >= TileTab[Tab.TabIndex].tbr.TileCount) then + L := -1; + + with Map[MapY + N div MapW, // y + MapX + N mod MapW] do // x + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: back := L; + 0: mid := L; + 1: front := L; + end; + + Inc (N); + until (N >= MapW * MapH) or Eof (f); + + finally + CloseFile (F); + end; + + UpdateMap; + Modified := TRUE; + end; +end; + +procedure TMainForm.ExportMap1Click(Sender: TObject); + var + F: file of Byte; + i1: Byte; + i2: SmallInt; + i4, L: LongInt; + b4: array [0..3] of Byte; + MapX, MapY, MapW, MapH, N: Integer; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + with aMaps[CurMap] do + if ExportMapDialog.Execute then + begin + MapX := 0; + MapY := 0; + MapW := Length (Map[0]); + MapH := Length (Map); + if Selection then + begin + MapX := Area.Left; + MapY := Area.Top; + MapW := Area.Right - Area.Left + 1; + MapH := Area.Bottom - Area.Top + 1; + end; + if MapW = 0 then + Exit; + AssignFile (F, ExportMapDialog.Filename); + try + ReWrite (F); + N := 0; + L := 0; + repeat + with Map[MapY + N div MapW, // y + MapX + N mod MapW] do // x + case TileTab[Tab.TabIndex].tbr.BackMidFront of + -1: L := back; + 0: L := mid; + 1: L := front; + end; + if (ExportMapDialog.FilterIndex - 1) mod 2 = 1 then + Inc (L); + + case (ExportMapDialog.FilterIndex - 1) div 2 of + 0: begin + i1 := Byte (L and $FF); + Write (F, i1); + end; + 1: begin + i2 := SmallInt (L and $FFFF); + Move (i2, b4, SizeOf (i2)); + Write (F, b4[0]); + Write (F, b4[1]); + end; + 2: begin + i4 := L; + Move (i4, b4, SizeOf (b4)); + Write (F, b4[0]); + Write (F, b4[1]); + Write (F, b4[2]); + Write (F, b4[3]); + end; + end; + Inc (N); + until (N >= MapW * MapH); + + finally + CloseFile (F); + end; + + UpdateMap; + Modified := TRUE; + end; +end; + +procedure TMainForm.RefreshImportedTiles1Click(Sender: TObject); + var + ai: array of Integer; + s: string; +begin + SetLength (ai, 0); + + with TileTab[Tab.TabIndex].tbr do + if RefreshData.OrgFilename = '' then + ShowMessage ('This tile set was not imported.') + else + begin + if not FileExists (RefreshData.OrgFilename) then // 2.5 refresh file doesn't exist + begin + if OpenPictureDialog.Execute then + begin + s := OpenPictureDialog.FileName; + if FileExists (s) then + RefreshData.OrgFilename := s; + end; + end; + + if FileExists (RefreshData.OrgFilename) then + begin + MainForm.ProgressPanel.Visible := TRUE; + + TileTab[Tab.TabIndex].tbr := + ReadTileBitmap ('', + W, H, 0, 0, + ai, + 0, 0, + 0, 0, + ProgressBar, + FALSE, + FALSE, + TRUE, + TileTab[Tab.TabIndex].tbr); + + TabChange (Sender); + Modified := TRUE; + UpdateTileBitmap; + end; + end; + + + + SetLength (ai, 0); + + MainForm.ProgressPanel.Visible := FALSE; + +end; + +var + LastTSX, LastTSY: Integer; + +procedure TMainForm.TileSelectionMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + GetTileArea; + TileSelection.Brush.Style := bsClear; + TileSelOrgX := X + TileSelection.Left; + TileSelOrgY := Y + TileSelection.Top; + MovingTileSel := TRUE; + MovingTileSelPixels := Button = mbLeft; + LastTSX := 0; + LastTSY := 0; + SaveTempBmp; +end; + +procedure TMainForm.TileSelectionMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + var + i, j: Integer; +begin + if MovingTileSel then + begin + i := ((X + TileSelection.Left) - TileSelOrgX) div Scale; + j := ((Y + TileSelection.Top) - TileSelOrgY) div Scale; + TileSelX1 := TileAreaX + i; + TileSelY1 := TileAreaY + j; + TileSelX2 := TileSelX1 + TileAreaW; + TileSelY2 := TileSelY1 + TileAreaH; + if (i <> LastTSX) or (j <> LastTSY) then + ShowTileSelection (TRUE); + LastTSX := i; + LastTSY := j; + if MovingTileSelPixels then + begin + + Bmp.Canvas.CopyRect (Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H), + TempBmp.Canvas, Rect (0, 0, W + 2 * BORDER_W, H + 2 * BORDER_H)); + Bmp.Canvas.CopyRect (Rect (TileSelX1, TileSelY1, TileSelX2, TileSelY2), + TempBmp.Canvas, MakeRect (TileAreaX, TileAreaY, TileAreaW, TileAreaH)); + UpdateBMP (FALSE); + + end; + end; +end; + +procedure TMainForm.TileSelectionMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + TileSelection.Brush.Style := bsBDiagonal; + TileSelection.Brush.Color := $0080FFFF; + + MovingTileSel := FALSE; + + // SaveUndo ('Drop Selection'); + UpdateBmp (TRUE); + Modified := TRUE; + +{ + SaveUndo ('Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + with ClipBmp do + Bmp.Canvas.CopyRect (Rect (X1, Y1, X2, Y2), + ClipBmp.Canvas, MakeRect (0, 0, ClipBmp.Width, ClipBmp.Height)); + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; +} + +end; + +procedure TMainForm.Horizontal3Click(Sender: TObject); +begin + Horizontal3.Checked := not Horizontal3.Checked; + Vertical3.Checked := FALSE; + Diagonal1.Checked := FALSE; + GradientH := Horizontal3.Checked; + GradientV := FALSE; + GradientD := FALSE; + TileMouseMove (Sender, [], LastX, LastY); +end; + +procedure TMainForm.Vertical3Click(Sender: TObject); +begin + Horizontal3.Checked := FALSE; + Vertical3.Checked := not Vertical3.Checked; + Diagonal1.Checked := FALSE; + GradientH := FALSE; + GradientV := Vertical3.Checked; + GradientD := FALSE; + TileMouseMove (Sender, [], LastX, LastY); +end; + +procedure TMainForm.Diagonal1Click(Sender: TObject); +begin + Horizontal3.Checked := FALSE; + Vertical3.Checked := FALSE; + Diagonal1.Checked := not Diagonal1.Checked; + GradientH := FALSE; + GradientV := FALSE; + GradientD := Diagonal1.Checked; + TileMouseMove (Sender, [], LastX, LastY); +end; + +procedure TMainForm.ProjectInformation1Click(Sender: TObject); +begin + Info.Caption := 'Project Information - ' + ProjectName; + Info.ShowModal; +end; + +procedure TMainForm.Fill1Click(Sender: TObject); + var + x, y, i, j, k: Integer; +begin + SaveUndo ('Fill'); + GetTileArea; + if Erasing then + k := TRANS_COLOR + else + k := Color.Brush.Color; + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + Pixels[x + i, y + j] := k; + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + + + +procedure TMainForm.Lighten1Click(Sender: TObject); + var + x, y, i, j, k: Integer; + R, G, B, l: Integer; +begin + if Sender = Lighten1 then + SaveUndo ('Lighten') + else + SaveUndo ('Darken'); + GetTileArea; + l := 256 div (MaxRGB - 1); + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + begin + k := Pixels[x + i, y + j]; + if k <> TRANS_COLOR then + begin + GetRGB (k, R, G, B); + if Sender = Lighten1 then + k := RGB (LimitRGB (R + l), LimitRGB (G + l), LimitRGB (B + l)) + else + k := RGB (LimitRGB (R - l), LimitRGB (G - l), LimitRGB (B - l)); + Pixels[x + i, y + j] := k; + end; + end; + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.FormClose(Sender: TObject; var Action: TCloseAction); +begin + RTTimer.Enabled := FALSE; // 2.31 bug fix + + if Modified then // 2.0 bug fix + if not SaveChanges then + Action := caNone; + + if Action <> caNone then + begin + WriteConfigFile; + Quitting := TRUE; + // SetEditorMode (mTile); + CloseAll; + end; +end; + +procedure TMainForm.RealTimeLightening1Click(Sender: TObject); +begin + with RealTimeLightening1 do // 2.0 + Checked := not Checked; + RTTimer.Enabled := RealTimeLightening1.Checked; +end; + +procedure TMainForm.RTTimerTimer(Sender: TObject); +begin + if RealTimeLightening1.Checked then + if Drawing then + if not Busy then + if DrawingTool in [dtPoint, dtBrush, dtLine] then + begin + TileMouseUp (nil, LastButton, LastShift, LastX, LastY); + TileMouseDown (nil, LastButton, LastShift, LastX, LastY); + end; +end; + +procedure TMainForm.Darker1Click(Sender: TObject); // 2.2 +begin + if FromToFirst > 0 then + begin + Dec (FromToFirst); + Dec (FromToLast); + FromToPaint (Sender); + end; +end; + +procedure TMainForm.Lighter1Click(Sender: TObject); +begin + if FromToLast < MAX_FROM_TO - 1 then + begin + Inc (FromToFirst); + Inc (FromToLast); + FromToPaint (Sender); + end; +end; + + +// 2.4: change tile offset + +procedure TMainForm.Up3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetY[Current] > - H then + begin + Dec (OffsetY[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.Down3Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetY[Current] < + H then + begin + Inc (OffsetY[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.Left4Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetX[Current] > - W then + begin + Dec (OffsetX[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.Right4Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + if OffsetX[Current] < + W then + begin + Inc (OffsetX[Current]); + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +procedure TMainForm.ResetOffset1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr do + if (Current < Length (OffsetX)) and (Current < Length (OffsetY)) then + begin + OffsetX[Current] := 0; + OffsetY[Current] := 0; + + UpdateTileBitmap; + DrawCursor; + UpdateBMP (TRUE); + Modified := TRUE; + ShowStatusInfo; + end; +end; + +// 2.42 +procedure TMainForm.UpdateMap; +begin + lmp := nil; + if MapTab.TabIndex > -1 then + lmp := SelectMap (TileTab[Tab.TabIndex].tbr, MapTab.Tabs[MapTab.TabIndex]); + if lmp <> nil then + begin + DrawMap(Rect(0, 0, -1, -1), false, false, false); + MapDisplay.Invalidate; + end; +end; + +procedure TMainForm.UpdateMapRegion(Region: TRect); +begin + DrawMap(Region, false, false, false); + MapDisplay.Invalidate; +end; + +procedure TMainForm.MapDisplayPaint(Sender: TObject); +var + r: TRect; + tw, th: integer; +begin + // To do: + // - Change DrawMap interface to reflect new functionality + // - Clean up zoom code + + with TileTab[Tab.TabIndex].tbr do + begin + tw := W * ZOOM_FACTOR div Zoom; // Warning: may truncate + th := (H - Overlap) * ZOOM_FACTOR div Zoom; // Warning: may truncate + end; + + // 2.5 + with TileTab[Tab.TabIndex].tbr.Maps.aMaps[MapTab.TabIndex] do + begin + CurMapH := Length (Map); + CurMapW := Length (Map[0]); + end; + MapDisplay.Width := tw * CurMapW; + MapDisplay.Height := th * CurMapH; + + with MapDisplay.Canvas.ClipRect do + r := Rect(Left div tw, + Top div th, + min(CurMapW - 1, -(-Right div tw)), + min(CurMapH - 1, -(-Bottom div th))); + if (VisibleMapRegion.Left <> r.Left) or (VisibleMapRegion.Top <> r.Top) + or (VisibleMapRegion.Right <> r.Right) + or (VisibleMapRegion.Bottom <> r.Bottom) then + begin + VisibleMapRegion := r; + DrawMap(Rect(0, 0, -1, -1), false, false, false); + end; + MapDisplay.Canvas.StretchDraw(Rect(r.Left * tw, r.Top * th, + (r.Right + 1) * tw - 1, (r.Bottom + 1) * th - 1), bmpMap); +end; + +procedure TMainForm.HideTileSetPanel1Click(Sender: TObject); +begin + with HideTileSetPanel1 do + begin + Checked := not Checked; + TilePanel.Visible := not Checked; + if Checked then + StatusBar.Parent := MainForm + else + StatusBar.Parent := TilePanel; + end; +end; + +procedure TMainForm.UseOldNoiseFunctions1Click(Sender: TObject); +begin + with UseOldNoiseFunctions1 do + Checked := not Checked; +end; + +procedure TMainForm.FormKeyPress(Sender: TObject; var Key: Char); + var + sp: TSpeedButton; +begin + if Key = '+' then + ZoomIn1Click(Sender); + if Key = '-' then + ZoomOut1Click(Sender); + + sp := nil; + if Mode = mTile then + begin + case Key of + '1': sp := PencilButton; + '2': sp := BrushButton; + '3': sp := LineButton; + '4': sp := RectButton; + '5': sp := EllipseButton; + '7': sp := FillButton; + '8': sp := FilledRectButton; + '9': sp := FilledEllipseButton; + '0': sp := SelectionButton; + end; + end; + if Mode = mMap then + begin + case Key of + '1': sp := MapPointButton; + '2': sp := BlockButton; + '3': sp := ZOrderButton; + '4': sp := MapRectButton; + end; + end; + if sp <> nil then + begin + sp.Down := True; + SetDrawingTool (sp); + end; +end; + +procedure TMainForm.ExportMapasImage1Click(Sender: TObject); + var + Scale, WW, HH, x, y, i, j, rgba, RR, GG, BB, R, G, B, C, Total, BGC: Integer; +begin + lmp := nil; + if MapTab.TabIndex > -1 then + lmp := SelectMap (TileTab[Tab.TabIndex].tbr, MapTab.Tabs[MapTab.TabIndex]); + if lmp <> nil then + begin + if SavePictureDialog.Execute then + begin + SavePictureDialog.DefaultExt := GraphicExtension (TBitmap); + bmpMapImage := TBitmap.Create; + + case SavePictureDialog.FilterIndex of + 1: bmpMapImage.PixelFormat := pf24bit; + 2: bmpMapImage.PixelFormat := pf16bit; + 3: bmpMapImage.PixelFormat := pf15bit; + 4: bmpMapImage.PixelFormat := pf8bit; + 5: bmpMapImage.PixelFormat := pf4bit; + 6: bmpMapImage.PixelFormat := pf1bit; + 7: bmpMapImage.PixelFormat := pf24bit; // PNG + end; + if ExtractFileExt (SavePictureDialog.Filename) = '' then + if SavePictureDialog.FilterIndex = 7 then + SavePictureDialog.Filename := SavePictureDialog.Filename + '.png' + else + SavePictureDialog.Filename := SavePictureDialog.Filename + '.bmp'; + + DrawMap (Rect(0, 0, -1, -1), TRUE, FALSE, FALSE); + + Scale := MapExportScaleDownFactor1.Tag; + if Scale <> 1 then + begin + BGC := TileTab[Tab.TabIndex].tbr.BackGr; + WW := bmpMapImage.Width; + HH := bmpMapImage.Height; + with bmpMapImage.Canvas do + begin + for y := 0 to HH div Scale - 1 do + for x := 0 to WW div Scale - 1 do + begin + RR := 0; + GG := 0; + BB := 0; + C := 0; + Total := 0; + for j := 0 to Scale - 1 do + for i := 0 to Scale - 1 do + begin + if (x * Scale + i < WW) and (y * Scale + j < HH) then + begin + rgba := Pixels[x * Scale + i, y * Scale + j]; + if rgba <> BGC then + begin + GetRGB (rgba, R, G, B); + Inc (RR, R); + Inc (GG, G); + Inc (BB, B); + Inc (C); + end; + Inc (Total); + end; + end; + if C < Total div 2 then + Pixels[x, y] := BGC + else + Pixels[x, y] := RGB (RR div C, GG div C, BB div C); + end; + end; + bmpMapImage.Width := WW div Scale; + bmpMapImage.Height := HH div Scale; + end; + + if UpperCase (ExtractFileExt (SavePictureDialog.Filename)) = '.PNG' then + begin + bmpMapImage.TransparentColor := TRANS_COLOR; + WriteBitmapToPngFile (SavePictureDialog.Filename, bmpMapImage, TRANS_COLOR); + end + else + bmpMapImage.SaveToFile (SavePictureDialog.FileName); + bmpMapImage.Free; + end; + end; +end; + +procedure TMainForm.RotateRight1Click(Sender: TObject); + var + i, j: Integer; + ai: array of Integer; +begin + SaveUndo ('Rotate Right'); + GetTileArea; + with Bmp.Canvas do + if TileAreaW <> TileAreaH then + MessageDlg ('Not (yet) implemented for non-square tiles/areas.', mtError, [mbOk], 0) + else + begin + SetLength (ai, TileAreaW * TileAreaH); + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + ai[i + j * TileAreaW] := Pixels[TileAreaX + i, TileAreaY + j]; + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + Pixels[TileAreaX + i, TileAreaY + j] := ai[j + (TileAreaW - 1 - i) * TileAreaW]; + if not TileSelection.Visible then + RotateBounds (Bounds, -90); + end; + + UpdateBmp (TRUE); +end; + +procedure TMainForm.RotateLeft1Click(Sender: TObject); + var + i, j: Integer; + ai: array of Integer; +begin + SaveUndo ('Rotate Right'); + GetTileArea; + with Bmp.Canvas do + if TileAreaW <> TileAreaH then + MessageDlg ('Not (yet) implemented for non-square tiles/areas.', mtError, [mbOk], 0) + else + begin + SetLength (ai, TileAreaW * TileAreaH); + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + ai[i + j * TileAreaW] := Pixels[TileAreaX + i, TileAreaY + j]; + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + Pixels[TileAreaX + i, TileAreaY + j] := ai[TileAreaH - 1 - j + i * TileAreaW]; + if not TileSelection.Visible then + RotateBounds (Bounds, +90); + end; + + UpdateBmp (TRUE); +end; + +procedure TMainForm.aaClick(Sender: TObject); + var + s: string; +begin + with Sender as TMenuItem do + begin + s := Caption; + if s[1] = '&' then + system.Delete (s, 1, 1); + if Length (s) = 1 then + aaN := StrToInt (s) + else + aaN := 1; // Off + AntiAliasing1.Caption := '&Anti-Aliasing (' + s + ')'; + Checked := TRUE; + end; +end; + +procedure TMainForm.ReplaceColors2Click(Sender: TObject); + var + FirstTile, LastTile, CurTile, OldCurTile: Integer; + X, Y, RGB, R, G, B: Integer; + FR, RR: Boolean; + FR1, FG1, FB1: Integer; + FR2, FG2, FB2: Integer; + RR1, RG1, RB1: Integer; + RR2, RG2, RB2: Integer; + tr, tg, tb: Integer; + ar, ag, ab: Integer; + DF1R, DF1G, DF1B: Real; + DF2R, DF2G, DF2B: Real; + DF1, DF2, DF: Real; + Avg: Integer; + + function Check (x, P, L, Tol: Integer; var DF1: Real; var DF2: Real): Boolean; + begin + Result := FALSE; + + DF1 := -1000; + DF2 := +1000; + + x := x - P; + if L > 0 then + begin + DF1 := (x - Tol) / L; + DF2 := (x + Tol) / L; + end + else + if L < 0 then + begin + DF1 := (x + Tol) / L; + DF2 := (x - Tol) / L; + end + else { L = 0 } + begin + if Abs (x) <= Abs (Tol) then + begin + DF1 := 0; + DF2 := 1; + end; + end; + if not ( ((DF1 < 0) and (DF2 < 0)) or + ((DF1 > 1) and (DF2 > 1)) ) then + Result := TRUE; + end; + +begin + Replace.CurColor := Color.Brush.Color; + Replace.ShowModal; + + with Replace, TileTab[Tab.TabIndex].tbr do + if Result then + begin + FR := FindRange.Checked; + RR := ReplaceRange.Checked; + GetRGB (FindColor1.Brush.Color, FR1, FG1, FB1); + if FR then + begin + GetRGB (FindColor2.Brush.Color, FR2, FG2, FB2); + Dec (FR2, FR1); + Dec (FG2, FG1); + Dec (FB2, FB1); + end + else + begin + FR2 := 0; + FG2 := 0; + FB2 := 0; + end; + + GetRGB (ReplaceColor1.Brush.Color, RR1, RG1, RB1); + if RR then + begin + GetRGB (ReplaceColor2.Brush.Color, RR2, RG2, RB2); + Dec (RR2, RR1); + Dec (RG2, RG1); + Dec (RB2, RB1); + end + else + begin + RR2 := 0; + RG2 := 0; + RB2 := 0; + end; + + tr := TolRed.Value; + tg := TolGreen.Value; + tb := TolBlue.Value; + ar := AddRed.Value; + ag := AddGreen.Value; + ab := AddBlue.Value; + + OldCurTile := Current; + FirstTile := Current; + LastTile := Current; + if All then + begin + FirstTile := 0; + LastTile := TileCount - 1; + end + else + SaveUndo ('Replace Colors'); + + for CurTile := FirstTile to LastTile do + begin + if All then + begin + Current := CurTile; + // StartEdit (FALSE); + + with TileTab[Tab.TabIndex] do // bug fix 2.55 - replace colors replaced tiles + Bmp.Canvas.CopyRect (MakeRect (BORDER_W, BORDER_H, W, H), + tbr.TileBitmap.Canvas, MakeRect (tbr.Current * W, 0, W, H)); + + end; + GetTileArea; + + for Y := TileAreaY to TileAreaY + TileAreaH - 1 do + for X := TileAreaX to TileAreaX + TileAreaW - 1 do + begin + RGB := BMP.Canvas.Pixels[X, Y]; + if RGB <> TRANS_COLOR then + begin + GetRGB (RGB, R, G, B); + + if Check (R, FR1, FR2, tr, DF1R, DF2R) and + Check (G, FG1, FG2, tg, DF1G, DF2G) and + Check (B, FB1, FB2, tb, DF1B, DF2B) then + begin + DF1 := Max (Max (DF1R, DF1G), DF1B); + DF2 := Min (Min (DF2R, DF2G), DF2B); + if DF2 >= DF1 then + begin + DF := (DF2 + DF1) / 2; + + R := RR1 + Round (DF * RR2) + ar; + G := RG1 + Round (DF * RG2) + ag; + B := RB1 + Round (DF * RB2) + ab; + + BMP.Canvas.Pixels[X, Y] := MakePalRGB (R, G, B, 0); + end; + end; + + end; + end; + + + UpdateBMP (TRUE); + UpdateTileBitmap; + end; + + Current := OldCurTile; + DrawCursor; + Modified := TRUE; + end; +end; + +procedure TMainForm.UpdateTileGrid; // 2.51 + var + i, j, w, h: Integer; + LW, LH: Integer; + CD, CL: Integer; +begin + with TileTab[Tab.TabIndex] do + begin + Grid.Picture.Bitmap.Transparent := TRUE; + Grid.Picture.Bitmap.TransparentMode := tmFixed; + Grid.Picture.Bitmap.TransparentColor := TRANS_COLOR; + + w := tbr.W + 2 * BORDER_W; + h := tbr.H + 2 * BORDER_H; + + LW := tbr.W div 4; + if tbr.W mod 4 <> 0 then LW := 2 * tbr.W; + LH := tbr.H div 4; + if tbr.H mod 4 <> 0 then LH := 2 * tbr.H; + + Grid.Left := Tile.Left {+ BORDER_W * Scale}; + Grid.Top := Tile.Top {+ BORDER_H * Scale}; + if (w * Scale <> Grid.Width) or + (h * Scale <> Grid.Height) then + begin + Grid.Width := w * Scale; + Grid.Height := h * Scale; + with Grid.Picture.Bitmap do + begin + Width := w * Scale; + Height := h * Scale; + with Canvas do + begin + Brush.Style := bsSolid; + Brush.Color := TRANS_COLOR; + Pen.Style := psSolid; + Pen.Color := TRANS_COLOR; + Rectangle (0, 0, Width, Height); + end; + for j := 0 to h - 1 do + for i := 0 to w - 1 do + begin + CD := clBlack; + CL := clWhite; + if LW * LH <> 0 then + if ((i - BORDER_W + LW) mod LW = LW - 1) or + ((j - BORDER_H + LH) mod LH = LH - 1) then + CL := clRed; + Canvas.Pixels[i * Scale, j * Scale] := CD; + Canvas.Pixels[i * Scale + Scale - 1, j * Scale + Scale - 1] := CL; + end; + end; + end; + + end; +end; + +procedure TMainForm.ShowTileGrid1Click(Sender: TObject); +begin + with ShowTileGrid1 do + begin + Checked := not Checked; + Grid.Visible := Checked; + end; +end; + +procedure TMainForm.ReplaceSelectedTile1Click(Sender: TObject); + var + i, j, x, y, w, h: Integer; + + function CompareMCR (mcr1, mcr2: MapCellRec): Boolean; + begin + CompareMCR := (mcr1.Back = mcr2.Back) and (mcr1.Mid = mcr2.Mid) and + (mcr1.Front = mcr2.Front); + end; + +begin + if Mode = mMap then + if Selection and (ClipTab.TabIndex > -1) and (clip <> nil) then + begin + w := Min (Area.Right - Area.Left + 1, Length (clip^.Map[0])); + h := Min (Area.Bottom - Area.Top + 1, Length (clip^.Map)); + + with Area do + begin + for y := 0 to Length (lmp^.Map) - 1 do + for x := 0 to Length (lmp^.Map[y]) - 1 do + if ((x < Left) or (x > Left + W - 1)) or + ((y < Top) or (y > Top + H - 1)) then + begin + for j := 0 to H - 1 do + for i := 0 to W - 1 do + if CompareMCR (lmp^.Map[y, x], clip^.Map[j, i]) then + lmp^.Map[y, x] := lmp^.Map[Top + j, Left + i]; + end; + + // for j := 0 to H - 1 do + // for i := 0 to W - 1 do + // lmp^.Map[Top + j, Left + i] := clip^.Map[j, i]; + end; + + Selection := FALSE; + UpdateMap; + end; + Modified := TRUE; +end; + +procedure TMainForm.MoveMapLeft1Click(Sender: TObject); + var + lm: LayerMap; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if CurMap > 0 then + begin + lm := aMaps[CurMap]; + aMaps[CurMap] := aMaps[CurMap - 1]; + aMaps[CurMap - 1] := lm; + MapTab.Tabs.Move(CurMap, CurMap - 1); + Dec (CurMap); + MapTab.TabIndex := CurMap; + Modified := TRUE; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.MoveMapRight1Click(Sender: TObject); + var + lm: LayerMap; +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if CurMap < Length (aMaps) - 1 then + begin + lm := aMaps[CurMap]; + aMaps[CurMap] := aMaps[CurMap + 1]; + aMaps[CurMap + 1] := lm; + MapTab.Tabs.Move(CurMap, CurMap + 1); + Inc (CurMap); + MapTab.TabIndex := CurMap; + Modified := TRUE; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.NextMap1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if Length (aMaps) > 0 then + begin + if CurMap < Length (aMaps) - 1 then + Inc (CurMap) + else + CurMap := 0; + MapTab.TabIndex := CurMap; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.PreviousMap1Click(Sender: TObject); +begin + with TileTab[Tab.TabIndex].tbr.Maps do + if Length (aMaps) > 0 then + begin + if CurMap > 0 then + Dec (CurMap) + else + CurMap := Length (aMaps) - 1; + MapTab.TabIndex := CurMap; + UpdateMap; + ShowStatusInfo; + end; +end; + +procedure TMainForm.N110Click(Sender: TObject); +begin + with Sender as TMenuItem do + begin + MapExportScaleDownFactor1.Tag := Tag; + Checked := TRUE; + end; +end; + +procedure TMainForm.SplitColorPattern1Click(Sender: TObject); +begin + with SplitColorPattern1 do + begin + Checked := not Checked; + if Checked then + with OtherFromTo do + begin + FT := FromToList; + ExFT := ExFromToList; + F := FromToFirst; + L := FromToLast; + end; + FromTo.Repaint; + end; +end; + +procedure TMainForm.ShowBackLayerClick(Sender: TObject); +begin + ShowBackLayer.Checked := not ShowBackLayer.Checked; + UpdateMap; +end; + +procedure TMainForm.ShowMidLayerClick(Sender: TObject); +begin + ShowMidLayer.Checked := not ShowMidLayer.Checked; + UpdateMap; +end; + +procedure TMainForm.ShowFrontLayerClick(Sender: TObject); +begin + ShowFrontLayer.Checked := not ShowFrontLayer.Checked; + UpdateMap; +end; + +procedure TMainForm.SetGridGuidelines1Click(Sender: TObject); +begin + with SettingsForm do + begin + X.Value := MapGridX; + Y.Value := MapGridY; + Caption := 'Map Guidelines'; + ShowModal; + if Result then + begin + MapGridX := X.Value; + MapGridY := Y.Value; + UpdateMap; + end; + end; +end; + +procedure TMainForm.HalfSize1Click(Sender: TObject); + var + i, j, ShiftX, ShiftY: Integer; + XM, YM: array[0..1] of Integer; + WW, HH: Integer; + X1, Y1, X2, Y2: Integer; +begin + if Mode = mTile then + begin + if Clipboard.HasFormat(CF_BITMAP) then + begin + X1 := BORDER_W; + Y1 := BORDER_H; + X2 := X1 + W - 1; + Y2 := Y1 + H - 1; + + if TileSelection.Visible and + (TileSelX2 <> TileSelX1) and + (TileSelY2 <> TileSelY1) then + begin + X1 := TileSelX1; + Y1 := TileSelY1; + X2 := TileSelX2; + Y2 := TileSelY2; + end; + + SaveUndo ('Scaled Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + + ShiftX := 0; + ShiftY := 0; + XM[0] := 0; + XM[1] := 0; + YM[0] := 0; + YM[1] := 0; + for j := 1 to ClipBmp.Height - 1 - 1 do + for i := 1 to ClipBmp.Width - 1 - 1 do + with ClipBmp.Canvas do + begin + if Pixels[i, j] = Pixels[i + 1, j] then + Inc (XM[i mod 2]); + if Pixels[i, j] = Pixels[i, j + 1] then + Inc (YM[j mod 2]); + end; + if XM[1] > XM[0] then ShiftX := 1; + if YM[1] > YM[0] then ShiftY := 1; + + WW := X2 - X1 + 1; + HH := Y2 - Y1 + 1; + WW := Min (WW, (ClipBmp.Width - ShiftX) div 2); + HH := Min (HH, (ClipBmp.Height - ShiftY) div 2); + + with ClipBmp do + Bmp.Canvas.CopyRect (MakeRect (X1, Y1, WW, HH), + ClipBmp.Canvas, MakeRect (ShiftX, ShiftY, 2 * WW, 2 * HH)); + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; + end; + end; + +end; + +procedure TMainForm.N256ColorPalette1Click(Sender: TObject); + var + PalFile: string; + i: Integer; +begin + Pal256 := not Pal256; + N256ColorPalette1.Checked := Pal256; + + if Pal256 then + with TileTab[Tab.TabIndex].tbr do + if PaletteNumber = -1 then + begin + PalFile := '.\' + DEFAULT_PAL; + if not FileExists (PalFile) then + PalFile := ApplPath + DEFAULT_PAL; + if FileExists (PalFile) then + begin + PaletteManager.NewButton.Click (); + PaletteManager.ImportPalette (PalFile, PaletteManager.PaletteTab.TabIndex, 2); + PalMan.DefaultPalette := PaletteManager.PaletteTab.TabIndex; + + if PalMan.DefaultPalette <> -1 then + begin + for i := 0 to Tab.Tabs.Count - 1 do + with TileTab[i].tbr do + if PaletteNumber = -1 then + PaletteNumber := PalMan.DefaultPalette; + end; + + end; + for i := 0 to 255 do + begin + Enable256[i] := True; //(Random (256) < 128); // True; + LastEnable256[i] := True; + end; + end; + + Palette.Repaint; +end; + +function TMainForm.CountEnabledColors: Integer; + var + i, j: Integer; +begin + j := 0; + for i := 0 to 255 do + if Enable256[i] then Inc (j); + Result := j; +end; + +procedure TMainForm.ReplaceCurrentTileSequence1Click(Sender: TObject); + var + i, j, m, n: Integer; + mcr: MapCellRec; +begin + if SeqTab.TabIndex > -1 then + begin + if not Selection then + Exit; + + // check if not empty + n := 0; + m := 0; // frame lengths provided as map codes? + with Area do + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if mcr.MapCode > m then + m := mcr.MapCode; + if not EmptyMCR (mcr) then + Inc (n); + end; + + if n < 1 then + Exit; + + SeqW := n; + SeqH := 1; + + + with TileTab[Tab.TabIndex].tbr do + with Seq do + with aMaps[CurMap] do + SetMapSize (Map, SeqW, SeqH); + + n := 0; + with Area do + begin + for j := Top to Bottom do + for i := Left to Right do + begin + mcr := lmp^.Map[j, i]; + if not EmptyMCR (mcr) then + begin +// if m = 0 then +// mcr.MapCode := 25; + seq^.Map[0, n] := mcr; + Inc (n); + end; + end; + end; + + SeqTabChange (Sender); + + { RD: clear selection } + Selection := FALSE; + UpdateMapRegion(Area); + Modified := TRUE; + end +end; + +// 3.00 +procedure TMainForm.SaveHistoryCoords (x1, y1, x2, y2: Integer); +begin + if bHistoryRec.Down then + begin + HistoryListBox.Items.Add(Format (' %d,%d, %d,%d', [x1, y1, x2, y2])); + end; +end; + +procedure TMainForm.bHistoryClearClick(Sender: TObject); + var + i: Integer; +begin + HistoryListBox.Items.Clear; + bHistoryClear.Down := False; + bHistoryRec.Down := True; + UpdateBMP (False); + for i := 0 to UndoCount - 1 do + Undo[i].HistoryCoords := ''; +end; + +procedure TMainForm.bHistoryShowClick(Sender: TObject); +begin + UpdateBMP (False); +end; + +procedure TMainForm.HistoryListBoxClick(Sender: TObject); +begin + UpdateBMP (False); +end; + +procedure TMainForm.ProjectLists1Click(Sender: TObject); +begin + Lists.ShowModal; +end; + +procedure TMainForm.bRGBEditClick(Sender: TObject); + var + filename: string; +begin + filename := ApplPath + RGBCONV_FILE; + RGBConv.lblFilename.Caption := filename; + if FileExists (filename) then + RGBConv.Script.Lines.LoadFromFile (filename); + RGBConv.ShowModal; + if RGBConv.Result then + begin + RGBConv.Script.Lines.SaveToFile (filename); + LoadRGBConvNames; + end; +end; + +procedure TMainForm.LoadRGBConvNames; + var + filename: string; + lines: TStringList; + LastSelected: string; + i, j: Integer; + s: string; +begin + filename := ApplPath + RGBCONV_FILE; + lines := TStringList.Create (); + lines.Clear; + if not FileExists (filename) then + begin + lines.Add ('[Black & White]'); + lines.Add ('R=(R+G+B)/3'); + lines.Add ('G=(R+G+B)/3'); + lines.Add ('B=(R+G+B)/3'); + lines.Add (''); + lines.Add ('[Invert]'); + lines.Add ('R=255-R'); + lines.Add ('G=255-G'); + lines.Add ('B=255-B'); + lines.Add (''); + lines.SaveToFile (filename); + end; + + for i := 0 to Length (RGBConvScripts) - 1 do + RGBConvScripts[i].Clear; + SetLength (RGBConvScripts, 0); + + lines.LoadFromFile (filename); + LastSelected := ''; + for i := 0 to RGBConvListBox.Items.Count - 1 do + if RGBConvListBox.Selected[i] then + LastSelected := RGBConvListBox.Items[i]; + RGBConvListBox.Items.Clear; + j := -1; + for i := 0 to lines.Count - 1 do + begin + s := lines.strings[i]; + s := trim (s); + if (s <> '') and (s[1] = '[') and (s[Length (s)] = ']') then + begin + Delete (s, 1, 1); + Delete (s, Length (s), 1); + RGBConvListBox.Items.Add (s); + + Inc (j); + SetLength (RGBConvScripts, j + 1); + + if (s = LastSelected) then + RGBConvListBox.ItemIndex := j; + + RGBConvScripts[j] := TStringList.Create; + end + else + if (j >= 0) and (s <> '') then + RGBConvScripts[j].Add (s) + end; +end; + +function TMainForm.ConvertPixel (color: Integer): Integer; + const + IdChars: set of Char = ['0'..'9', 'A'..'Z']; + var + i, j, k, r, g, b, resultR, resultG, resultB: Integer; + c: Char; + s: string; + N: LongInt; + p, ErrorPos: Integer; + F: ShortString; +begin + GetRGB (color, resultR, resultG, resultB); + for i := 0 to RGBConvListBox.Items.Count - 1 do + if RGBConvListBox.Selected[i] then + if (i < Length (RGBConvScripts)) then + begin + for j := 0 to RGBConvScripts[i].Count - 1 do + begin + s := trim (RGBConvScripts[i].Strings[j]); + if (s <> '') then + begin + c := UpCase (s[1]); + if (c = 'R') or (c = 'G') or (c = 'B') then + begin + Delete (s, 1, 1); + s := trim (s); + if (s <> '') and (s[1] = '=') then + begin + Delete (s, 1, 1); + if (s <> '') then + begin + s := '(' + UpCaseStr (s) + ')'; + GetRGB (color, r, g, b); + for k := Length (s) - 1 downto 1 + 1 do + if (not (s[k - 1] in IdChars)) and + (not (s[k + 1] in IdChars)) then + case s[k] of + 'R': begin + Delete (s, k, 1); + Insert (Format ('%d', [R]), s, k); + end; + 'G': begin + Delete (s, k, 1); + Insert (Format ('%d', [G]), s, k); + end; + 'B': begin + Delete (s, k, 1); + Insert (Format ('%d', [B]), s, k); + end; + end; + ErrorPos := 0; + p := 1; + F := s; + if Evaluate (N, F, p) then + begin + case c of + 'R': resultR := N; + 'G': resultG := N; + 'B': resultB := N; + end; + end; + + end; + end; + end; + end; + + end; + end; + ConvertPixel := RGB (LimitRGB (resultR), limitRGB (resultG), limitRGB (resultB)); +end; + +procedure TMainForm.bRGBRunClick(Sender: TObject); + var + x, y, i, j, k: Integer; +begin + SaveUndo ('RGB Script'); + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + if Pixels[x + i, y + j] <> TRANS_COLOR then + Pixels[x + i, y + j] := ConvertPixel (Pixels[x + i, y + j]); + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.SelectNextClip1Click(Sender: TObject); +begin + if ClipTab.Tabs.Count > 0 then + ClipTab.TabIndex := (ClipTab.TabIndex + 1) mod ClipTab.Tabs.Count; + ClipTabChange (Sender); +end; + +procedure TMainForm.SelectPreviousClip1Click(Sender: TObject); +begin + if ClipTab.Tabs.Count > 0 then + ClipTab.TabIndex := (ClipTab.TabIndex - 1 + ClipTab.Tabs.Count) mod ClipTab.Tabs.Count; + ClipTabChange (Sender); +end; + +procedure TMainForm.ReplaceColorUnderCursor1Click(Sender: TObject); + var + x, y, i, j: Integer; +begin + SaveUndo ('Replace Color'); + GetTileArea; + with Bmp.Canvas do + begin + x := TileAreaX; + y := TileAreaY; + for i := 0 to TileAreaW - 1 do + for j := 0 to TileAreaH - 1 do + if Pixels[x + i, y + j] = ColorUnderMousePointer then + Pixels[x + i, y + j] := Color.Brush.Color; + end; + UpdateBmp (TRUE); + Modified := TRUE; +end; + +procedure TMainForm.Edit1Click(Sender: TObject); + var + map: Boolean; +begin + map := ((Mode = mMap) and (Selection and (ClipTab.TabIndex > -1) and (clip <> nil))); + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP) or map; + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP) or map; + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP) or map; +end; + +procedure TMainForm.UseAsAlphaChannel1Click(Sender: TObject); +begin + if Mode = mTile then + begin + if UseAsAlphaChannel1.Checked then + UseAsAlphaChannel1.Checked := FALSE + else + begin + UseAsAlphaChannel1.Checked := TRUE; + + AlphaBmp.Width := W; + AlphaBmp.Height := H; + AlphaBmp.Canvas.CopyRect (Rect (0, 0, W, H), + Bmp.Canvas, MakeRect (BORDER_W, BORDER_H, W, H)); + LastTileEdited := -1; + end; + + AlphaPanel.Height := 12 + H; + AlphaPanel.Visible := UseAsAlphaChannel1.Checked; + AlphaPaintBox.Width := W; + AlphaPaintBox.Height := H; + + end; +end; + +procedure TMainForm.AlphaPaintBoxPaint(Sender: TObject); + var + i, j, k: Integer; + x: Integer; + rgba: Integer; + r, g, b: Integer; +begin + x := (AlphaPaintBox.Width - W) div 2; + for j := 0 to H - 1 do + for i := 0 to W - 1 do + begin + rgba := AlphaBmp.Canvas.Pixels[i, j]; + if (rgba <> TRANS_COLOR) then + begin + GetRGB (rgba, r, g, b); + k := 255 - (r + g + b) div 3; + AlphaPaintBox.Canvas.Pixels[x + i, j] := rgb (k, k, k); + end + else + AlphaPaintBox.Canvas.Pixels[x + i, j] := AlphaPanel.Color; + end; + +end; + +procedure TMainForm.ShowUsedColorPatterns1Click(Sender: TObject); +begin + with ShowUsedColorPatterns1 do + if not Checked then + begin + Checked := TRUE; + + ColorPatternsPanel.Visible := TRUE; + MainForm.Resize; + end + else + begin + Checked := FALSE; + + ColorPatternsPanel.Visible := FALSE; + MainForm.Resize; + end; + UsedPatternSelect := FALSE; +end; + +procedure TMainForm.ColorPatternsImageMouseMove(Sender: TObject; + Shift: TShiftState; X, Y: Integer); + var + j: Integer; +begin + if UsedPatternSelect then + if Length (FromToSave) > 0 then + begin + j := Y * Length (FromToSave) div ColorPatternsImage.Height; + FromToSavePos := j; + SelectSavedFromToList; + if (FromToSave[j].F = FromToSave[j].L) then + SetColor (FromToSave[j].FT[FromToSave[j].F], False, False); + end; +end; + +procedure TMainForm.ColorPatternsImageMouseDown(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); +begin + if (Button = mbLeft) then + begin + UsedPatternSelect := TRUE; + ColorPatternsImageMouseMove (Sender, Shift, X, Y); + end; +end; + +procedure TMainForm.ColorPatternsImageMouseUp(Sender: TObject; + Button: TMouseButton; Shift: TShiftState; X, Y: Integer); + var + i, j: Integer; +begin + if (not UsedPatternSelect) then + if (Button = mbRight) then + if Length (FromToSave) > 0 then + begin + j := Y * Length (FromToSave) div ColorPatternsImage.Height; + + for i := j + 1 to Length (FromToSave) - 1 do + FromToSave[i - 1] := FromToSave[i]; + SetLength (FromToSave, Length (FromToSave) - 1); + if (j >= Length (FromToSave)) then + j := 0; + + FromToSavePos := j; + if Length (FromToSave) > 0 then + SelectSavedFromToList + else + begin + ColorPatternsImage.Picture.Bitmap := TBitmap.Create; + with ColorPatternsImage.Picture.Bitmap do + begin + Width := 1; + Height := 1; + Canvas.Pixels[0, 0] := ColorPatternsPanel.Color; + end; + ColorPatternsImage.Repaint; + ColorPatternsImage.Refresh; + end; + DrawUsedFromToList; + end; + + UsedPatternSelect := FALSE; +end; + +procedure TMainForm.DoubleSize1Click(Sender: TObject); + var + i, j, k: Integer; + px, py: Integer; +begin + if Mode = mTile then + begin + if Clipboard.HasFormat(CF_BITMAP) then + begin + + SaveUndo ('Scaled Paste'); + ClipBmp.Assign(Clipboard); + ClipBmp.Canvas.Draw(0, 0, ClipBmp); + + GetTileArea (); + + for j := 0 to TileAreaH - 1 do + for i := 0 to TileAreaW - 1 do + begin + px := i div 2; + py := j div 2; + if (px < ClipBmp.Width) and (py < ClipBmp.Height) then + begin + k := ClipBmp.Canvas.Pixels[px, py]; + Bmp.Canvas.Pixels[BORDER_W + i, BORDER_H + j] := k; + end; + end; + + + UpdateBmp (TRUE); + TileSelection.Visible := FALSE; + Modified := TRUE; + end; + end; + +end; + +procedure TMainForm.Edit1DrawItem(Sender: TObject; ACanvas: TCanvas; + ARect: TRect; Selected: Boolean); +begin + Paste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + StretchPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); + ScaledPaste1.Enabled := ClipBoard.HasFormat (CF_BITMAP); +end; + +procedure TMainForm.HideOnionSkin1Click(Sender: TObject); +begin + HideOnionSkin1.Checked := not HideOnionSkin1.Checked; + UpdateBMP (FALSE); +end; + +end. + diff --git a/Main.~pas b/Main.~pas index 5a8a5e2..156f839 100644 --- a/Main.~pas +++ b/Main.~pas @@ -1001,8 +1001,8 @@ type Sessions: Integer; History: string; CDROM: Boolean; - ReadParamFile: Boolean; //CMDLINE-OPS - resultCMD: Integer; //CMDLINE-OPS + ReadParamFile: Boolean;//CMDLINE_OP + resultCMD: Integer;//CMDLINE_OP ReadParamCMD: string; RecentFiles: TStringList; WinLeft, WinTop, WinWidth, WinHeight: Integer; // 2.55 @@ -8952,8 +8952,9 @@ procedure TMainForm.Generate1Click(Sender: TObject); // options StartWithEmptyTile: Boolean; + ExportDuplicateTiles: Boolean; // ignore unique tile check - + RunCMDLine: string; // run command line const MAX_COUNTER = 100; @@ -12039,7 +12040,8 @@ procedure TMainForm.Generate1Click(Sender: TObject); StartWithEmptyTile := FALSE; - + ExportDuplicateTiles := FALSE; // ignore unique tile check + SetNumVar ('TRUE', 1); SetNumVar ('FALSE', 0); @@ -13166,30 +13168,69 @@ procedure TMainForm.Generate1Click(Sender: TObject); var i: Integer; s: string; - begin + begin for i := 0 to lines.Count - 1 do begin s := UpCaseStr (Trim(lines.Strings[i])); - if (s <> '') then - begin - if (s[1] = '!') then - begin - Delete (s, 1, 1); - - + if (s <> '') then + begin + if (s[1] = '!') then + begin + Delete (s, 1, 1); + + if (s = 'RUNCMDLINE') then // run command line + begin + RunCMDLine := UpCaseStr (Trim(lines.Strings[i+1])); // read next line + Delete (RunCMDLine, 1, 1); // remove first char + end; + + if (s = 'STARTWITHEMPTYTILE') then + begin + StartWithEmptyTile := TRUE; + end; + + if (s = 'EXPORTDUPLICATETILES') then + begin + ExportDuplicateTiles := TRUE; // ignore unique tile check + end; + + end; + + end; + + +// from https://stackoverflow.com/questions/32211723/why-delphi-app-cant-run-a-bat-file-and-make-it-work?noredirect=1&lq=1 +procedure StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); +var + StartInfo: TStartupInfo; + ProcInfo: TProcessInformation; +begin + //Simple wrapper for the CreateProcess command + //returns the process id of the started process. + FillChar(StartInfo,SizeOf(TStartupInfo),#0); + FillChar(ProcInfo,SizeOf(TProcessInformation),#0); + StartInfo.cb := SizeOf(TStartupInfo); - if (s = 'STARTWITHEMPTYTILE') then - StartWithEmptyTile := TRUE; + if not(ShowWindow) then begin + StartInfo.dwFlags := STARTF_USESHOWWINDOW; + StartInfo.wShowWindow := SW_HIDE; + end; + CreateProcess(nil,PChar(ExeName + ' ' + CmdLineArgs),nil,nil,False, + CREATE_NEW_PROCESS_GROUP + NORMAL_PRIORITY_CLASS,nil,nil,StartInfo, + ProcInfo); - end; - end; - end; + //Result := ProcInfo.dwProcessId; + if WaitForFinish then begin + WaitForSingleObject(ProcInfo.hProcess,Infinite); end; - + //close process & thread handles + CloseHandle(ProcInfo.hProcess); + CloseHandle(ProcInfo.hThread); +end; { TMainForm.Generate1Click } @@ -13394,7 +13435,7 @@ begin for j := 0 to N - 1 do if not found then begin - diff := FALSE; + diff := ExportDuplicateTiles; // ignore unique tile check for y := 0 to tbr.H - 1 do if not diff then for x := 0 to tbr.W - 1 do @@ -13680,7 +13721,14 @@ begin ErrMsg := RunCode; - + // run cmd line if not empty and no errors + if RunCMDLine <> '' AND ErrMsg = '' then + begin + // StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); + StartProcess('cmd.exe', '/C ' + RunCMDLine, TRUE, FALSE); // execute, show window and wait? + end; + + for itab := 0 to Tab.Tabs.Count - 1 do with TileTab[itab].tbr do begin @@ -13688,23 +13736,19 @@ begin H := LastH; end; - - if ReadParamCMD <> 'F10' then - begin - if ErrMsg <> '' then - ShowMessage (ErrMsg) - else - begin - with ProgressBar do - Position := Max; - // mgarcia removed CMDLINE-OPS - ShowMessage ('Code generated successfully'); - end; - end; - end; - - - +// CMDLINE_OP + if ReadParamCMD <> 'F10' then + begin + if ErrMsg <> '' then + ShowMessage (ErrMsg) + else + begin + with ProgressBar do + Position := Max; + ShowMessage ('Code generated successfully'); + end; + end; +// CMDLINE_OP // clean up and release memory @@ -14751,7 +14795,7 @@ begin begin Modified := FALSE; Open1Click (nil); - {CMDLINE-OPS} + //CMDLINE_OP ReadParamFile := ParamCount > 1; if ReadParamFile then begin @@ -14766,7 +14810,7 @@ begin Exit1Click(Self); end; end; - {CMDLINE-OPS} + //CMDLINE_OP end; ReadParamFile := FALSE; end; diff --git a/Tutorial/tutor.html b/Tutorial/tutor.html index b1b2510..53b6186 100644 --- a/Tutorial/tutor.html +++ b/Tutorial/tutor.html @@ -1082,8 +1082,24 @@

    -!StartWithEmptyTile - inserts empty tile at the start of the export image, to align with the starting from 1 not 0 -!ExportDuplicateTiles - exports duplicate tiles, ie when not using tstilebitmap +!StartWithEmptyTile +- inserts empty tile at the start of the export image, to align with the starting from 1 not 0 + +!ExportDuplicateTiles +- exports duplicate tiles, ie when not using tstilemap + +!RunCMDLine +- run a command line executable after the export script has finished, put command on following line, ie: +#end file +; -------------------------------------------------------- +!RunCMDLine +;"C:\Users\My Name\Desktop\My Project\convert.bat" "C:\Documents and Settings\My Name\Desktop\My Project\file01.png" true + +Tips: +0) Path and command must be full qualified and in quotes on the next line, with the first character skipped +1) Execution directory is where the excutable is launched from (where your ts.exe is, ie C:\ts\) not your project folder +2) If you use a batch file, the first command should be a cd command into your project folder, put pause to debug it et +3) if the cmd box flashes and does nothing, it's most likely your paths are wrong, test first on the command line. diff --git a/ts.exe b/ts.exe index 7de7c9d2eb5131eec9886a5eb0466d1dd7efe520..6f4a275fc5845541f34e0ba14259d4c03e69c89b 100644 GIT binary patch delta 313989 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

    )6mCaR$`MCG6!F-x}zXy_kIE{Kw z25aTSJC^g?FDPg20=sf{>E%Rd<=jF~z6acJj9z(9b~O5&q1Qi<0d(m->1FtZoZi>O z(!0Gcd--%pNBxd-&qjNhKGIs&isrqKjm^Ohwr9BV7tO%zhlSjNW90DxSe@9~eITd90{yBFWCW=A!|ZLK-#-9JF`e31V~dn zC{jbgI^nbhg_>5grAzhA8F;0ctX0dk$7qh-g-4yT@}=`1$__nqF)B;|%)~*5Z8Nn5 zvD%Jz=W7hHKfye>L)}chPRc-^c}R({xoe-mjH#+!Ow&%vJKT?=y3?yBY81^usyZnv z4EeO|BRRUoF^m8VBcZ2$rBfft2`%R65f{`g6n;t$@L7j*90u(gYhwkLaaHYPT7F7C zZ8%uo>0{XQffz^OC-R6lRte^;W~kijd(5>LXvU{9(LQ=#Euvwf?^D^wK6(*Hdr;%2 zau@6jrF}O`pea)KNnl)>P^Yg8~v)iAR$k%65WGL+X7HW?2{ctuS$F65z zQPITbwlGID4!mpTU|>6MPB};0j$h?a`~W*m|T%VQAZh*frR) z7apJ$U2_l@1Sw9FTk%up^?h8PoG3?GOqL#z75oC0h}xp8r|9;*z5uJS-QVkfZhbwC zsDaoeSSMesc;N?qcROqij@IaBdXGz`;W(EU8dSSFec{}CI~r-87BN3T-Jd7Oh;%Ti zE;A%QNz$`}2l12EVx42_d>`Uah@y4LAk=oQc>5=C>9G*_>Z1O6T}QFtl0IKoBI+-p zzg!RlF6)QsCX1ZQ7=P2m^OyB8`4=9A^0M4>C5E%6)XVB;(skCMI3 z>US~qTYWpx=3n~Ae41h&qeYfv73?mE!bOhn&@Em;d(`!XdO)bCJZ5Ne23kqcbZULs zCb?CWQR>m}WE4M&vKUcpO>z8p%HJ~FMn6LNcc3KeY-3?^W?|)H;?sZW-^<*C;~8zJ zF|*N7=wwT!93IuR{ZbGSO2$l8g}upJSMAUc2XbuwW#8wX1a~RC{e0t_&r!uVXWlM< zC!Q2+fC>L6?)glD^a$=4W>-fm(>uf~RbAtiM4Wwx0%pB?SdOGZjz%k|DGbaem@Jq| zKPWg1j#mm`4t9&jol1JhQj#C<`ihx@E z3g}=)2ZbuRn%Y2{tp{wUUPQ!KVcrslYxSLbZ-#XMOeBl}CJClD46U#6jzM|rDPOkP z@xD?u_VL$;92Bls(9;i!9{BV=h)_WYMZcXl&^%gtFY z@~|kb)At!N7!#c204JldpuadBxvS|2i?;--EZkq~1Q6S3tppWK{8oqc^c>-IRUhm& z5?(ZiJda)>75iQVv*yA*;i-b|rf+OD@iCpN3rCle``zOSsKGf@6zJ)O4Hnh10nyWJ zb=;MX5UE%;5^ln6q;g4SY?-aQ$lT4Kyt+D5wfO!j2E(PI)vx+tp<{s}FwOk1JRa|2 zRQ0P`;A!Q}7I<2Z?pa+sT`c@n-?iiNThkdP7zD4L9#{_ zXRhhHdNg8{Wo>$=N@{mJaN}}a?=v#zwzV|x=&T|9!8?_T;|np^gWYCDu#Y*}ou+Ne zdT|+|Qv1w8pQ^5%Ddt_r`OXvKh3i;v7Kww`F?qy`+t>9Ed3vG#C2N|XM&DY6CaOZc zzC-&}O-Mx3us>%U)uKtAhHrK4RFPA!A28|`{I!9vxqJa7NsZKO$J9GFsep|w3h2?I zfVw-f4b)2@(CXTsL_<9$yA8toH_UDW#H8Q!9o+sQgEXn*WDva7^czsWPVE0ppC9ns zSVFyn(XHaRu_Wm#ZDo$B%Nvm+xCv2W-0xTcJ$09|xT&=x%DW0K>neripiYDWgev@DX_=OZo4BKRK&g23p}TXqJ+tblj(VRilNp{{cBeVC+sE5(UoFsCk$T0CD6!{eqCR%f^cjonXca?4(P+S(98xSVsX_sj7H>T3M=M4o;M-d#bj$e(qvW~VgIO0)yO?HjKxU>jk z4X0Ba5Jo;KOF`Tzh&XT;tZ{N;Jq+iMccIM9LEO2kpV2N1C_mjRS}I4-bRZOnT(dsK zy(JLky)3>p>*F~=H->KR!iMUyH&10NoyrlPd4sgP2n+Ov1_H!Q+k7Z`Oho`BCm*FG;INpgl~NcCPRF)U_#)R2a_|+psa>*nQl<7 z;#)rxchs_g=w$}w@(TEmK^#=>G}0?Vg+fuGaD?3l_|>tnG~w>XYB(An#djVeCF7zc z5=umY3INZefElO(+!!mgVRs|Z0K|YTPNI-aQFyksdHi*h6di?rWfa+tEC559$&t}x z!FwE8U?+M|-qJM-KyC%L2jw&DkR@Vyh%1gP*fY*@7mmW%D|*`L>qA6mC)R^aN=2c> zI49=YO$E`WL+e^1ftq6|PKtBljO+zeN~l}KeOxCN=$PRROe4K?@l%ssV7}iG2sp0# z?P6DN$HNM%1^X$ zVI9Eo?Crw5(W?zE?4kAr2!we;N=4JN(-OnPQdlmYa$!AvkHVijH~TNvEeFI@bwPaL z!hG-)?iGac5AsFZSVGAGlTkV}Wtecb)7O>t&#y!f>#v|a@JZv5<@Y??ZQ<5qf+_-G z+&?7zm)C{wVG@NtiS#}}xB0)7um7JYh_q@52graH_Qo`t1#|+Fe1RD!_>f(?nOt234RUXVXEFi zIGEl05eFvwU6klO^i>#r1;W6j!<;&U5fk6tFq6JS{7UrWN}wwRnPkD_!G!O_kOY$f zlLMpw8j;^eqA&$8MKBv-w!+lIgnxjrFc)C9!T23O;xH%RmxT-}VL~Vz%r?M74r1Ak z?>?CQFb5A{EW7|<)jxrOLr4tfAdC-S2cJg?tC87T7=7MGB$xsucou~^`#Ea(5wKH* z)m=FX3*+(zU@+w{K`>D;r%F&Le1qRa`lnI*k1-y@9tw>409$H4{!RfU%K@y1=jtOE zXOE&Fh*bI%3IY466SRqH?un)Fc&1r?m5LD~(=xQ=aEyL_q` zwjK#kk(D)Tnq|bI+CKm(`w_O~Z(Crqy8!kg7#9o>57Hppa)9`+mDiv8NsbWz3j@Ry zAP|(=@>cA>A0e~>;{JyMf-h+ZO}_|+tW7* zejS_L_3(3on+_}g{_?`TI;vVA^g(xC^Z&+|-vlD~f1x?xe=_1K-{ym)x1dLEx_`)h zFhWm%i|+kBdiHsAF?=_`}^pN1Pp49eCXe>(^<_KH`Q55}29Bn~jbcdNW$jTgdT!LuA4<8(d5A|JM4>`P!o(uvK6+JiRR zG1yL>Qo5j9!Fa%|L97y(%`h**?1ia-ISTUy%nvYiFpVO~mwC4fLX;e!lYU2GPw!%Q zrlT(o(x35V-G+Cs1F^s~Tm_~6ibNVP@%@D<{wC(9+kh+a%I>=uvuiO>Hsan-3bA@p z7R|uAFR`no9sfLs1{cDvWT0d6{<{!asM3k@R=8Yfy( zZN5TRA1zC>|Am3~KaIPfo93mNHcs59$VE))!2HF64onY*`ic&$Lq4I!9&8xf^->Gj z5&9l9{Q7mj7meXP?sa>>P4n4*QW0oDYrYb<6%-G?h;@>G(EZ^5MYMv@4*e&*{- zJbFRBN*TtNRyBP>_oFN&X05%9Ge8vDa(2w~4ygLrI)Hs~g;YmVD zH@B_KK)f8lI=4+lAv%~AhvLFTn{nffWgAi}z6oG&>GF}BdKu5dkxbxh&-cU0y~*O% z?v_A?vhr#OW|>|4!2CbA<~*L(I}QP~$2#I5!9C6N$%qeVcZ4$?zpk2;Ix*J>MAJcY z8lkOn0Nm3eKDC^ZL_5{a zZ6t#BBS&gh)$Lxl^$G1002e2Q!|A4av~6*UCI0NfyzJ>rLTz#rZM(8i$YIBJWnJjv zQdjnj*IxIQ;$$aqOoSt&DB<3X^@=zQzZU0VwmTZ{11{yo;-l1#uCQB<#2DT6Scc;=z+%<2Jgq&wRWq5GvhSP7RD zfXA(SvM?Oh4)4jLLzYbC+K)~8+AX9?K1Z$1&~}adCI11+waN!i0ro7fx2}$<$}{|hq8TSOLrKx z=Dgd6g9s4Y-;7h$eRIUKz1Wk`knS16ItCz&x(KIv38UQBB%rg%_=R~6%1T#QMM?-8 z7DxH#wgFz{Q`_bCx6M0b+IMAgNMIHo#Dg$yo2cACE9fP>99Y+;u+g03f>SzV`gI7{ zv2#S*-fXlSB>MQ$Adwv|2MHQway>CfSKunT4{MLWllrhIX9OM^6P^=EIDEAa8yz9b-MefPzP;?9>wl!zk)f;d;~jQWNV|Kg#Cm=C?PspNJojNDC@9DfY;pjo}~%q%Vi6&u~rfBUqIS80uBY7Qgg6z1uboUSFK@!aq?S|U+; zHL!!sMRX5k9pzi9q2>vC$l+S*Ive8|zY#kwC@0$VwN}a5I}n4aTaY(f$@MiQ=#A?5 zArcjCT8Iq@Q5R|&t2cRTfN8)>U7%+F1a`L%zb*@b95=*-ciY=xAlw^q+wAtCw+;Fa z3Ed1Rp-lW3$~FJmUf~CF0=wYp2=AmcU@`wL?_@84R$sBf2J6PMwN|#p$-A|XD$`q1BX`uOTqz;9m(ZNED zIZl)T5G)Cq}&6 z#4XAp<*1o#gP(h%b3^=$NKwgg(R%sTmjHAwBjPuz`2%e&hE)=wqcD=HtmHgeMqgRb zP<;EG^>xfomTXG2$lGP z0_)zkE`YLzqBY@3$grjuuf_6|9ir1+LV0d?D=ZX*+ggKpSYWav+(OCFG)@wxW;ETx zyU9C|C~|xi-K_2flBD;-tHzSJX{KcRlI2Tzd#tvca6V@OZ zx`BQBeM)39B~ourYJ!NPId`wE1h3mN8!Iy#V9N~4NZhlXEXs$lj(7+D%nKtsx$Hztgha9~16)U1v3Sg2*5OXE$&-X`)g4F# z4Y>p|?XkFpa?PyjZc4~>EV9MgNH(T_cSKb`f#e^_o*h@C<(OuXzVm<|$^M-~V~|Am zX?&||KNI%DSZ|#W1BS8gVKSf3{zBP})6><37y)zicmUe2T-QQM?j@N}lNv7*h!f8Y zW8Ji?QH#Z)VXTX{OeImKvfLEwV=5@Xn5SM6w}!Efwl|fBv+dY%93IXl$H?%mH;`+i zDIv$S*k|Zk9Puf+gPQAp{ZII&<(bx|5K)z2uEi3;hM6x!Mig6%OZdM;G5@&oBm-UZ zz|3^?EN(ISZb!@27cb5#e$?f7yhG(AY*_arNKx!m(0a0kF|`eECti(a?#`)HbTl6MU;nyN-PObJ5bJG_^dJOBY%}UF~GcnjF z{ZmxMuorY)#H3i(CHXdmN14qSU}Lk14zlH@3E$#$m*Y_m=aw0i8@L1Sw)rsKe8@a> z9djc^`V!Re(QNt7c{Sbh#bt!pN7fgFMvAksELqF4M)ZzjKk6cdtAQThC$fj!xF9w0Yj{dCwCBjwM{=p{k%te0+d#prm}%1-yAFec)h5|^P8SzowbN@M{6 zRlibwEhPA_6zZH!nX58V%(ts+n|>GHA%>QFTX8#)KD^SKyU`ib)+Sw}aYG$QQ=^%NQcBHO}w6kE(sA4H!i7OO|G!5%c+ z zY+%6i>Md-{ zdRcAhBio~gNEyqjb$f)5k#)oEizp-W?Nf*z0zSeqwGUAvsjrxe4VMk|n?Uv?D{K6X z@*h*N&d7cu?G>}evlY56;+OF(%I@tcV*5zeSz>#-%RSg0Hy6d*EoLOMaJTnyJVMy+ zb&ZnhQL!%>`&Ud1JQcgt9^ybM_F%D(QA;<1<%6qbq3XrQh%cdd(}?r7=sW>UN~$KF za8+`6LEaQ4w^jeD>T(?z9MjW8#sucw)#~lAK59y0h}|M<0BlRM(3+-^4rCE8PGB8I z$(A1bqZ|u^wAG|8$J^w3t_6NmaEVXt^)u15+T;Ya3Kl+vqh>MZ&d?^jR%tB07iF-( z!QzwSZ2C;=Kj*QHI_i!!A=YNZZy3r}&#A~s1I@ccpTGdmzmE%cPzQ<^(%C%SV&U{K z`@wtD1+=B%Mx94V(qC9_QO~I{t1Bza53_bUbdq+Du(v(`HB(MnbRWm4js&*?ed9;* z-6O2MXVG^=ccvcTU6;>L8M$s=U`o*3mU+kWm+=V zio{9a)%+?pPQpU#WAV-;)}_NvM5yyI#RWSWO{0Sy!Dhg&G4s$TW_5kVACnl@;X2u^ z$t5e7Hn1{-EDyNYE~*!fmqZlq0P{{0=kyk)MX*XT0~$E4`$ zR%RAvrrfPtT1HJ?kQb!nWJ{|Q7M_aRJVXMoPGiF`fBkD3GwMpkpy}+m&&~xJ^<`DU zlB&Ljj_|PQ#0TLOUNdk^fLGVXW#TA-iM&iU9P-kYnQRt+SZA2CSP*VG1>- zOHS8+3ZI2+PMhuUp<%^vno^1V_?D>oM&~K^EM#WP?t2z7gYKz{>x)=-o!^WjL^$i? zg58S^E(Obj-Id&I!ob&Nb)@K@!%pe0Y{_L0$lEvo_ZR3)dwqbimBR=$rDgD3*2I z3$1mOS4Wq9Y&IunRc%8zs!70-vv33Ee`FXX7A;|65p-KTPv0ijwWP3!RwV5|0kQkj z9T^J)!t<~WOwUG(_gHuzD|{6pl~SX)xP z5chz_EoFUN7G452*5y$?H-u>^%g}8WSC@iIc}cX*W8K@x^?4gCVW_8`Ooa-NQF*M$ z?fPo1bM87oIs73m=CRwSzWtB^n09*^M4w^TQIM| zya#g<<}3`sei5aQvz5BYiohq>^E%y4@xe0ItF=-jlQ|ak7*e??{#eFDz!t!U6&sYd z@vVaS4(1mN49w5n%h_{wtBS>eWvplGB7{RRwD=RnvK1`Uw*s(%>kZ21_+Enf3x>n( zRdI9$M5mngnG8zj1f$7wpSZk|-L_LUh@bLVzJ{B+cQo9fnJt zsJ#eQUEBD9_@Mwtj8HFCz>;)N3&Seb+j~oiEK_D-M#^x^}cEUd2XgndH4~ z%j6kxc@^90wiN;=v=?c5i_#q_OizNmWn(=92pWqLItC^i4X^9Omrt@Wtsg-dZ0+%s zc&L!Yy0u1V3L1c*^14VN>!A@c_9=xZ>V9#ukd4zozlxyMEJm~M5?QOUggGVNTFtUG z&=t{n4V$mob1Sy4!AcFx_>b4J&bnlAZ7qAuJ>*R}k@lde>SMD?`qzM9E|#uiJw4yR zX}x8Lsm6AF1F)cO7w@fO&*-W|ViEI;%LF4THmqbbUEYCSpUJP?GHVVRCf)%l;v!B- z>}d5YHW#*vzKdkZ|DpE@Q@zFRB2f1V@mUcYtQA!euEi|OkJf?nzeXA*Q5e&${r_Qb zrqpsVxfqMl0#RIyo>L(9&?i!yEM`v!2JdTu)YT9=C|N`C)r<(QrlQR1A5 z#p4sWferCFgYBhYa`Hp)ZXSYO>Q#9MwpYsZFp@B zKh=H@s`|?Fv`Ia?7sJdot2fSA+;-n;sk3MI37w)&tLXX+R^lEwRZ?==%Hyb^>7ls} zCLA;5HrzQ8tOVRGOFto8q_sCj`MwsTSU+9trO;`Nu<4Bc$eZaZf6G%o%LkQ`C!l2Rg_ z95JePZ^RXwv~Y()5O6t*4vFi9F0=>aXY2*y=W|B zxBZL%LEYRPoFW%_R4OmhQ7^1Et8<0>4)(alCV08x=^Z%U?u14#8-q=!wYypyu=Jny z9-7w`>%V`HM53A^-rb2KyCPA$6CAe8r>PSZ%Xy?^oeWToQLt`M;fFM};20JCNsdk~ z2x$q29S){w==BSJM(ep+#FtwRpHD-ek1CT3V0CTs7MjVh#M92`+jj!8VX3yXn? z;>TS$Ff0&vcCkdasSp9Afo&94*44GEM9M2{4zy@gy}~>qydctN8EIl2N)qERE0ba$ ztRtV26|rn7yCGP?irY$#10|GIiB|gP+p@w}y=Apx8bv!vqRpaj_DB5CMF(ZHW zI(y!(gU4Fx6>H2n-i7(dyA3p$pgqAAxV=UcmZS51Rk6FAIklqQ!88KzYei56`_oQ0 zv%>2GwoV7t{4X6~eR`HZp%GD`q`p2Ne(O+_)#`*sL^|0ceyq5007q}SY|-YQETpTX z%GOJ1&XiaAI(=-Tjnu1>EcTmm_C4*N*mu1q&is=Nb?bp3bnSA^5+cg?h2J6eb+F|9 zdm)3V}hP%`zxA&gi1pYKH_*;o9dR8OXw{iJ2nD_s2T!s`b*&S> zfn;2~5n6!iT+0$g_fJ?)ukqQ|g)nJN$;p*dYo*Bggmto8ghw>N=^C;TY|&W=M@QR3 z2hhl$OK1GoQZdc1%|IE{53}HFIqd!sX;==s{lvGQfWufQ>`$?P^bE)tHlO%IO%N?1 zY*a84z9_hg!-pLC)>aO%N|B|5`I%EKi*gbHEF27VM4iN=Bu!s& z@Ka_7FQ=yi@oY5;ozJYTW+ z9Q#t&Z~aV^aG4&%Y|p}c2PGH0r=8fRVm_6TKlvBJzD$)mW=huMED4Gv^S)!f{J(t! zExe);=ZOaBXai$87CpB(9qYH$tec|hI~MGw{6b{~1E$y*j?GlXAK$Tsc2FQT<9jyU zTPN%njpa&`u=-1vRz0p7Ji|0**&$XIA*%sxDNRNi~Um~`v*44?aM0? z1?owVywu|N1M3$u-7%h;O-`q7>W%bUE#+GbO_=-WIL1^(O(cSUWc_@4rZzWCYuGJa zeqF`9AHgxveOR%j2D1qmE{A_&$xw6bc@c6(A!74IOqavNXBW|M!^G8#SfqrApi3ah z)uQ+k>xa+5OE`aV5Ij2u}E`#$DQSsts)@Y|qK#Rl+zhF5%P86u%Z9O4&sHogQ z@s*14ce}W$vWZ|trqr@W+|euCR#QDSMO-1`!&){9Oe*IqEI;Ix8-#~O^+p5Da1rBZ z?P42fs^LkD&W>r+TLUZJyTZQHX=?A*-Lm;8ngt0WdaRIpuS8Y-8SuH0`=+YwPZ?w^x+}_2Sq(VDL^Mw zJzH%b8GFk-AuB?R{0)uUO04{iJ<&cw5Bf5CV4*q@$IPZ!4|PclQaG;87j1uMWBW<} zWb*&*SNK<}t>JBJjZ)N))ZggQlxo&kLPd=D$M5Vb(8sJlzys_dcK^WwygwLEky5jI zLA2I3)2REQDuE4l>jxmMRo_mc_~oKY1IX+bk*!DRtotP$^_Y6~tzi_!Y!Ki433?s2%O=(w*gQdH@MqP)hsG?XGO(hIC z-?K+yViM7I{GztHc0rGR7%PM=BM)M-RC4{YwgRTMeGGLy zmsJXTvg!)Q4)TWn5}*(g6xUF&ta1wY4EYh%>bLp~`5lB`8Nd*LRzJr`zM~4!vrbu{ z0DeHgqXevJ2JRx@2?91Y12+=z6an4aXo({FG6J3^U~n@qlYnOl7-0qG8`W_HJx9LA5wM1U%bS6133wSmTgQ3^Ws|e@H}I;i9XAN{a-FtssCa6!VSN97 zijp>B%$U*1hIyh?&wuHP*f<0&xTX8E!SCld!R%QzM_gyzOG<=Q-#wATVO;CHW-DoCPpW<0(AhexHPmJ;!3l*?{=tvXY0?K5 z)?iLt|0UMN)L70(iuJ*CkYSX62u27_LypuW4^O0R8xCwNZJLwsfI<^usL+;Om#X%* zutG4`x?2}HUlNd5x)Mmo5NZ`bI4dH%CX(;jS z!O>zn3u52asV_~?DerH9X!Qr%@K;6`f7Kz7!pk~K<@P|)NZdNdJ?jG8$*MB|J80Qz zBhl@Eqrz&^U^$to27Gbc&>xhlVo@TVci?mLXL?#YznLvS6>`HX_fbt|eTiuaFC~~O zN$C51;@p}%N5`PH|G*@rp{pd^+Cqh}+47x-B*EpuP({kpz{{XP=7uew!rqjRZtLl|ey-WwUU>zMDwqs}$ct`qOKU+ z+C;Gv56lmP%C-!cIH-C{fuSc)=H)=c!wk~MhBt@N>!^70EtGpas1m_wgjR|J>29NY zPMZ3*bX@kSK~hmL_!W?$OHOz{Z|3|(kDIC%06&%=WW?}0*9=g0!+r#Y&fV_OQlQ;% zTJHb%>X!z@|Jxf{?g$?oh&m#SUb$nwY5v1pZ$1U62OvH{Ptq7zdf!#>F62>(p84p6{#OCHui<+vaF822V zsk#foqfwz2ILLy8ll6Cy?4VQY?+3WA!juxg%lZCmcd0v}bmhO%KWIew|EPaZyyeP! zF&E$~O#I}^+x4Onp(ffrBCVyV&}Tu%EofL#7C`k3={#~$5y1x~Zj2JGAJPRTq9^&l zkSdyTnAI@*Vb0=4RTjPnVbVcNq>82hW)lplqB#h28pf)M#znl_n)mV{Ei`5I$mLM7Nj&bx=eRZwfPjcsNo+c1@gtu?h-Tfo8@Ju2`9ZSgf;wXb78?rZCfwFj+rUY} zRAHLL)h6_mW3lN_25mXrd{Jby;XbjOkRFx_kogKzn>t}^bHU2L14O>nYjByCh8C`L zQ1a_c38Cuu1dt2IC71P@B zER7i#A--tG*X2uI-J2b6;gSr=LN&{gz3>3ox(C1(KL9r60kBaIfDP&x{r8MJKOmsn z17NpnzZL{rkcvRP}4Af>@ z6Evifw{CHeW&W0(>PuV!v$!SsRl^O|NKN;6-2QaLM^Rzi<*iNMeX;Qhbe5QF@O8%X zyi@1V#ol>ypcu%HcfbjSqdy-6eaX@OoUXP`^ylrz6=0PB)g1C7?Fc*y2(fd_064XT zYL3hBYxzsWJz(pvJM5t_|7HUGKfU665LcV6SCkJ9q3T>WpTZXtzPwmzyYPz%pNc~h z{=FVl=uILmfIkA|;_n1-dfKZd01f}LXcfqN(Ys)Q+#kotNrAj;zN;tb^|;!#6&7m= zqt&|}v??o37;Q>O!9g8Ue+9rgB22|Y8kP}Zq|YrgE%vQyLp71zSs~V@wvJdU5xqEe zv?(?eyUpdUk+jUn=Y`9{bSpX%>!f`S@lO7UHMhng$)nd}=Hbjw)d`m%ls!WX4&oi$ z79eHfC*+{BN{(+39{@(gb3r_>b7*hs1Ek|uRU}K{?e-w4U$NCPMNuVO)g%$tk+0Sr z74LWCv2-Zb5qL-uJv#9{p?llO?g?~a*(o((LufNKYw1JQs+bmsPnbY*oYCO@<_!~e zoq6{JEWFjV5%-jO(2FSb$H0pzHZBtM6PV*D#RIQ{plme163J3MGBHd@#iO0Mf1ivW zQ0XtEly?K=-9OZtH_#|O_e)R75%CfSJ9EPje}o~9$WnJo=p%2`xS5ePM0z%;6Q$>F z=?Qem1F0A>G?)jrk;$^=JjaST!Mu|OJ|ktnWp0oQ4d#!!4eqPuw%m;?Cip$1Je87U!l2>dL!oIfqHG%(;Vz z=*oA=H-J9JR-uKIQUMO>)OMg-8&*3ZeL}_}S1Mi=Xs!h^hD*-|HC1}%iM`Fqf=zwHW4UBd2dA+Yekz{wzP^;?H`w>LAoilINU?+Xy&LcBH?w78!@@LDdBvB~*(v&V=LQlF>CSiPGAcUs z;Cpqh*pg#+p6Y^gsRhHtnVx)HKuP%hxPGX$4c7}qbT2EeZ@3az;yPJ8(Tg7)F%eM- zjYAwL$09Uq3p6g3o(-zM^qh0A=O*ddq(a9Aa5zS+3*iPX_g_QBnGn8DvqMO@H-8hG z@UT9-=QzT}cx<&=;G)&Dz{M7{ldWa9W9Xy)Vn8p&MigEa?W*8b4Ve&?)4FIv6iI91 zr1dlLW*;7}TUT+T4|meFSug~hYLuQ>R#J9&lV}sly)Gzb`jxBz(c1&?>X65u5t*KHX(k zdr^WVwyTF*TZlN=^(0xILLFUP>C1a!!1L_K({!&?%40#Ai7Fc=skbkoY04HjPv;$6f1w(bn(Q{4z;)um{vf(p$cJP>;4N`~-m zy{h7|BXh;mvh#AIb93g$XHT68UNLTOz~sP>kjK$g-WH2pWYMxj< z6&bJn_gs#0WUS=HD;sA(AI;-H#wswCR?_m-5W#yJQwqV{S%Go_GzsSDlL$s;Sv(Y$ z5H?5PL1`+VeY2B_Pn-@P3%gppcqEvBU=xPUsSe$D?Daa&fKXBia=Y52)|!E5y=DDQIut?cnK-7u;r+|sEXvC zj-((5${C>W^M^>@4KKRzVZ0+NLV$B3WEl6iQ&xyk!*~Z*QY)B(fMk5c;$gf?P~&Qe zf0?VBrjKwrmatKjCu$KcDu?kPh-iOH@gqXOhk?&V_@oQna2_yxC#-pB1pEr92JIC4 z39}Z@dMtYewALs^2ux$a2MveY6oQK%y zx4erYg#oXw?FsQf)$!oh`+6P!57P6A>vL zMk7D*k7(}UNboGc@mX8=$Iu=@jT5BWVyjgRn5+ha@1|W75dgHw@dhCJZ?Y}HVD zYL+f7RkQ4bnwFpm(MlBv*n%Oc4Gap;<2h7aCu4>|Ol5wInDVDxfXjjyWhcyPm<7T! zffqZ6#$n}A@;L6);4Vf2AFumLG$rssfv%Y2r7VZsTF%B2ghU53iw$>a?XbN}%}!deaKpMxaRqBGwW@6;$i#Tn_Ijd5~8$d9AW~xmvtx za1Nt(g;(7yL?K||mC(W?q3UC|085py00KrA9*I`R5HQ*nFoOaP5&0u{2Oc*86^s<6 zBY69Kug06^8wPVw4hg_|o~GPCK}>+6G|*WBRcfFD4Rnq`y8uFz)JF9M%E=yF$dCWJ z*}QHFLnaUd(Jqsmg%3{ie?vgayE|xq{B&aQNZzhX98#di$0P8aIP~;#ygjOhT43FQ zbt6RL@eBZhj&uPSZ?7HufT%}(37)2EVqHjyS$W40chVbiuuW^W&u>$KQnT{YuuPB& zbNZY6-@p!pYAQY(35MTRc&W)K3WOW&Ggp14MAdyR1DqWu%p0-_n)ovn%$D;wyAP2eCj>SuGaWu|C>K>OE}J zIuW15du#l^O7VCS@2A-d#9K++@@S(`{A9BSi8f<+PY=m$tp5e|Hp*+lQR(VaV(b{+ zLyP^6SUJX;DpDH5`)Kgd;%A%PNBEBAH=Wx4jzz3I;T0KvdQZ{U$k*tui3%eR>m)hS z8JCa?IMR6)Z=gegOny7$+c@-F+!_*U1JiUBG75iaq%RBTD%QMiNlO$x@~A)+yb z_jZfMI+%9tJFZgjG7*-_7vPG*u2lY#7VD@OF@Z1CjTZ+dfE8VdAzsA|x(S$W$BTe8 z-p!>R8Pj-)yDtmGxHKMz9JZwKQFsF8VjAz3lNwK1oix7ps*(jYg?JPHcxLwP;+j57M{^nvRv?oC(yEd z$U%`Yn{yhi&mdaeAoIY#2QwWT{s9TtspS;Jlcaxh+;9~ksj-q$Qx7A3TgU$yNunUy zRNeU_qJcYy#J9`&Y~2A7w}SU$7+%$DxFN}dqL!Cf>x>4K@`^j&BbFG+XG-TL>7+}w z(z!-DYpl*C;`|C8!OtQUwMzJ}*2eN|XrT5?d-6!KtCxwuIv zhaVOp8PC{YgqqTg5HbvZgqr!6?chKRIXFw58_uWecz-(k}u!`eFeSuDL z`yKIg5zlo6TTwlS2Qg`;*(=%<^BxlPvIUec5{h}ph_%>yWATQtnef1}_HDG+UB>g%8#rATOxVCPT+U(JYf(6ILA886Ytipe|9zOrl_zYwto~Htxd~@FX`*Tq_w)lUOi!kx`LsWU_S{3k%Up@y2EzHq0FXNPPaP8X}*IRWTT7sT9en@ysqX^$)h@{eB1a z>Z|I^m#Fu>D}uK0sR6S9)FyC@d9rxLcxKR2yg0Fa3-|TuW($MoYAJ=WQ?yc?-opE5 z^ntHd3TJ>Z{-6|>jq2<#D3|>^QG}mtMHpo%!iX2iQ;=u#nTJ-s%e3Ib%iBh^O0HjU zVMy?0ZnqE<fv2?pcRxoSfC!3W_Mgp69s( z|9_Wf@@UO-;j3agL!@p-;;cp0en01f_i3ru`{oDaN77lY}m4%K>oSi)TowScPNsqu606V&=aBb4(jCUwkSTaBYc1!;#3^PT@7Ml zWZ-)W-%@-};2VJ}7)S9fhr0^jBAodg#P<~9RpNUA{`>Jghi^H)3jp6YEFS>@*bP7& zzB};^1$v01(*!rMaaJSXR(wnG-GuK|d{GyYQyZGTQG)5LaHO1 zo_5GT!B$D}-=`Wu9|QQBs!#r#fEEC%wna~{b&?;EaCL1f^in!O!qigOo6^@UURGHH zgsIPzAz3LuYrhNf%+mHEY!=BIxuzZ5?3Rnv9u!jgc<;PLB5Io;*qo$xK)H5M2?3b| zrkm4OTgU@y3XkXxL#XnuBf%+y6A=1prwbVrY=fe-%@x@3{q z{u1xf!{@bo8LAQYxr5;b=U35QNb5o`q>=O{y^uEg8!0=gJ+x%YN~It32`wMj;}8xR-aSC{8iCIXUy^(JO1)pg_Mn0u{6f1QsK>lq`0B_WVWJ zs2UiDW-@W&we8qAY!g?vgGaevv@PYGn7#&ri(+soj|j^9@!pIa6g_28ge1Zc{h-)f ziZ$U`@op)$48fwQl>7MwzmD@a7kW))`uwH$K4KRn!pe9^{(gjL`8)AOv%3iPH(==D zZo02)I|cXvXPq(kzHo8kBEsPrnE$DUbtA%u{%^i1R8WhPvP(E4c@FCS@udeYJn+5u zO`*gGYOYsu5HR>(ICD_Jy;qpxq4U&5lwUPhnI{1fj-)5S)Wd|qy$PYk;g`9m-NqB* zpD%OY4un-wXm2GKJV6fv!bM0k^clU(10Bif0;iww-GNq%6N7hP2_GfWcko2rK2f#< zT-2yHahxNm4V}QRyt!Sdz1-hwcGtu2E(|?spM{+N-?URccq8hI0KjI{d%8+FD~nvH=MC%BhONC?%*ij52J@9{m|92 z5N4kk{R;ORPv=aXHJ9=W^ zhQ{liU_VUu$?L!~YV6?b0)_q=+maoLXEVmsNdiW&-I-p5@%eBO^&++0V*%~(8Z=DZn;66epKQz?R82Qvv` zvae%zf~S>V$Du}^SpPcYi6Kn#I`$qX#QE3xfWCeoU<7qZ(a3PbG`u>hJAw2zh5?Sp zQ;qW%&yq)?L?!kxp(6SXUKn_qyz$`fjLfOI**Qt`=grEQzeticZNpB9OKj%Ki_V-TmNx8Scgwqpbc{9K>J4f+Yr0Gwl+T;3%9N z!vtN|X2XpQn$$;4J>0+HVE=c_8V}>`E)1-tx8Od6dm#f8lst6Y2hN5Ce?dm&2p&@! zgEz2XavJ0R_NZ7E5(>K+uWUnqs)0Q&AJ4*7<3Sr3>w6kz?|rZ$f*6P-U-S+ zj|8RQAtZ>*wb%Hlk!ZCU0bF^YxsCWHiq3EI!u-$<35vU4f>MreBEISV3Cac-zkmeg z|6}jnQbM9YsX}#XFWLDk&Klc>_aC+G1MTSXoKh z-O|$9c*!VKtgP@-VOrs>9?}vM1&!R__nK$#&9=@tzjHq4^ZNe&`2En?^UQ6{ZOzP@ znKf%IgV_ah6h=U1ufqs|NrDWs7RDgTC7g|Mgt~2Zh)Qzbbna8ZA)(`w$AV3~|6|&N;9X7Zxvi&`?ci z1qE0ZzeNuc-qCtwp%(;UePDGv>Y+7-z>n{CyTeVWNb;#@!T&c=u~_&waq({p{{Idt z0yqCXT>S4*(IJC~Cqp&09GGFq5m9r3N2cWwF!DJE01~?Lax>#0wKFt#K z*b}ja+Qb672zS#2UZ6+vu-=8R&p#0T`XyuKlrfDAhOvMq@ZN$HH#46mYU1=un*g0} zm~i$mPowCsIKerUJMS}!-aY>rdEje99;hf-Ju5Ma!Cc4K6*v#Ew~S&BrJYDQV-!P! zY-tGUoj@}UK`jLtj;75ls7efUK87ag4xcXXqYGq~xEGvn zq+jxZpS{=h3u9Ig97! zJd!&aJ5|IjkqCI#eZU0b&di2a6!*G+pP1s1fjKRg?b;^>^tVz+pmJ=WmJARSD??8N zS}6h$wji1O%zm-UfIzH;1K~r)l8Tx+N^opnRjIA3kmL|0W6Ar)5e}UAV(a#c(XQ5= z3{_N2VgcJkZ)Zv}5hUILpv5Y7XTRtdx`o>2CZEGf2&MFb16Ok!hz(0`WWNVfvdm%* zh~5*ardjaHqMDi!oRUNfj@nL^*p)cv9wM!=DLO?ON^E*Gau?&3YJ^*YP>phsk=ZT) zA7@MD*#f`M%JH`gjj|q4$=JpiuEkjRa85H~Y(^*<^v;K%F>vAiVLPR`qP2MjVYYxq#~3?r|taFVf2hfU?! z1@SpE&DC#a0S7Vvm`T$q2Sw*mO-@+T(HdlIQ>K`?8|TC?T9}`UNKJ@9#x~MOOQf-j za~5e7E&J>s_~FdN>Td@{w_qyUE|iOmZQ{{_ICequ+*vsVEbt?Y*@g~Kg@$^Qk=f{v zL{H~%n~y~A zP)gVUCmGv>8Gj|9J>4>?T{%rXF*heCuZqQ0Tj*&|R#q)`Or}~_p~hrvfn`xS)4<$V zKrvd86&c$YlL#HggScLjGx$Iv%PzL}=r@@f+VXmr5*`IuGPVh)P=nH*$4tZz`B=0P z?lV3Xor|l#xSM1UzG`>x`4USEOzVG6LI|sdfXwM20udcTJws%OisRQ)j4<&fwfL^((jot@<5 zETHVQNAudr6bRL9mU&1F7mYXSpPKfcl`Nb6dI-yO z5$kYR?9-1jlAJO|E}|ANzN{^gD@I*G;^e7a$p9PPJkIQ!!;*z{a8=~iS7fS0?K zXX&@C8P0ki!IMeyz>_g8B(r(jGI&5x2}Pts{L3dShxp{$V|C4gbQ;t~U4>KlH1*&% zI&mjZBvD7Z?}nV%hZmW>)gkC-wW#oxNv*|?B}(q^Cp_rNt(j+s8%>^jO=AU}k`)b8rbK!!hv~s@^d|Y;gw0-U&miy61=~2^^X`jfnX|_~^;*pSk zSSWMUNtAgmE~C=aZ7<(~P!$TsMQTO!wG=ak1b9K~}^FIIb0Oved^&!!|)oztxCQ!!YR*938CpW$NlZI=9**n0*&(j2x4 zoycWp@u#J|ZlXa~K4jCNdpN{qHG%`{iy*vW#9a}IU?Y@h=M6ZY2T<+0W{TN~&%|{5 zZ}V=k{sE#p8~VA}Sv-aVd$o#Xel9-mIJiDh2#%ZigvU^J`*U%s<5r7%yD|HixRwM^ z{`!U3UzctS_)>&EfbqueUx^oVK_1_OZi5*I^B~MRn4K^`!g%4XA;j40I8MGKw0v46 zyxxCY{$3a8P{#tW6?{- zYf}hAhO=kt#l1RDmUdd))zKeE|G4-(QsPBBCeDxdojBPJQbP02it%H=z?naSO>5i{ zT+`?=0|-Hq$hG*80hyWWfb$kJhZ=a|J^}}hb$B`<$Ql{RzcHH5igr4WaX9?8CIK(; zPM}E(>+*vb>XwBd3}i!QGqlpxG(N#b{U8qN96ZUUiQjL5pqsO7(+@c4ie{huAof?# zdrG3da#aRv`vGFfGT7)J#bIe(vykevSxzBJdiIJX+e*$+ph;k+IvlWupuaxn67vjR zrl%XwBq+anBOOXK~){6~#H86y{LJr=H>`zPG8k*LuOq^#V< zCY%!^$8E>+C-uz&Fc~zJ?~XzGdHpe@w6TQO+ee7ADQ4aPTfb6@M*dL-{#l;oUK`_< zh20P8U&X#VhYiCXcH^AbgQhz}OiX#{RHQgkihUSqHd3Eqk>|x2Uz!VF7$*p|r56zZ zRVnSP(hJy==f&>sbm6Y`7*aj;1r{t!m7ks$Ctx-Vydb)}wnv~Y{e{I{5EFw4?ni07 z8x19c0b0G3h8_Y3L7sbA?qjwQ@jB0@czD^**H&F2GCaV(xCkzX<lilql6a4mwfK@4s0mLQ#|~TqtK|wd_$O@TXR|p! ziDNxb)9Bckf_}Vi)W&JlK%f7FT~VH~=_gEEUMLRojf-e9+kHh$A;AMz#5uUn&iNGw>s4&iuVUW#NjOc^bTyV# z;lx4E74|48nkW=-@d#C5K2SGcO|p3;9ScSr_3P0#qbnOAh&y)`25n8_V=VnQ@f*z8 zy{?MuNan#+G0&(pg%r1ty$QK=&g@$ihVjdAr`!k zl*AKq^EKcm-UM;tXDnV~8tS3UcbQ*YBy1n!m_F00&gzpO zt{8}0*_L5^{g(KXu45uLB-)Y$_UU{o$V-2ST?jrz6bM4}E*wz_g(IMB7D1o=AqH~k z1xFqrWNbnYa(Zg_At0lp(Y_6%(seW-5*Ia#r{>+nV*bR%Q68K0Cm4qF*x5hDKY*3> zcf`Kl$fR^hJYH*r0wp2x&pl+QU7-iHV1P*saN@zaLV*WmJ<=q0jiyqyMxyOv^dy0> zMm3PkT{s|%5Rnl28$y%Is$JKZHE9yiF#_vpc~{q~MMS?ybRt7YTt>@AS1mVncP3Z!yKy^DGcx&Kq9W zAfZ~7k=$PGJwKV32)<{?_d7(ikBd)3)tt2UIYizy@Sfbet{lFW=sU>&Eo+7V@ErLp zrj0lEAy)$}Ha4tb`d7^&nRJPt;>WO>o zefH85m^KsiQV$S359+12xh8M$ajgW;Al$amRQ~o5f(;&5Su$YId>~7qgauew%hP7@4lOUr<+dRv&G4<7 z6UV6oqBqhEUqK*uR4ll+pq+}#=4uJ&>uoP{!aQ@rR3r>9w0lXVcdX484IaZ!lkXjB*a;KE>f&+C2Mn$ zlD&4|4s~{ixQyB5aT#2PLZsmiB%SVHQ(dKnAaIVkN@;c&2Y#KTM&0vF>MUjVrHNwF z7;tSmSx!7g!DYp+mvQAv*cA(ut7(j3n>tHL*l2&>Svu&9q|sUNg)SK7XoT0@r5UPOiRo9 zo>cO6#w0IkG31`JgWgg%RQ|lTRAXls&R**(1rG#Otp1E8NRva(m#NKQ1XX(n;cSJ2 z{uGCL=%|u4v}3?K+RWTb>`qsyS5#UL%bG}Nb?_aN8tc>E!IwQ7zx4xL3w68bKFl?J z*i;{B7_j3xAIaw)t&!9~>U^aKk>ox<$p_YCSUmO_kAE2ZNk6F& z(H#7x{^-v^WL2@b{yc4&zZ3$`H~poq_g?9BR|D+C>nqQ@8X&r>O#^&$FB)J2nuLb% z9e=5=@0H$s2xuEUs2;tE=CcvMuHfn&+_~x*bOk@T36Ss@fb|NLeE6bY6fYF?MIW(o zfs!}MJ3mm0>BzOql1>)0@af;!fk4U6^#)*}A=Q^U6RcmE8YubV*w7(JddO4sz3s^i1qv=%;N6?L10H+80shbo+BT-!uLUa*?t256K$!`jF`;fWAQOJ;7q}egc zFvVPjY)8#WD}xpS`aT|S%zwiaz$qgiFr}K4B=dIw>RxDfAUYozDD24)$pc(8uY^c_ zI#AZrL1<80eIFt%E?(GQYvh>_wOiBpFxtw7u^67UcO@2UUCFDa)F%8s|ZPpd#XJmJ;HfR=fp^c-AihEm*` z!>Um$D?s6!Jo1OL?A}rZQvTLkihyE~fN&{J_Z)j590VnvBZf;Mp^hAro7EE-vDoZ1 ztDkzKk?PPqlhk*DF(JY019k>cb$-wEkz!q^<1&NZyRLSpx&^|KPTFr%4}H%OdgD*7aXrz>LjFDjZB!mN6ho(;qy?Jn$eC(!HgP9urRJgMxRc~-apwu{%p#`)C9YxX`b$0T zwcQ>8p>U9j7<}HD_73Kq(p6Z$EIy;S&lZ^}O0ZYkG(+{n=OYU}C#IkO@4y-+ek8G%rp`6uP6+RTPe zs_7bzMfWztq z{VfxJX`Gbq}UFC?2~DLtI*E5tO|6^U+&cMeQLJxKX@yQBq`a%~sDaWl-As0Lpwz$r({VPdT4_-fG!aY%;fWsQFEj_= zX{FV=JT?k=Tv|O?eU0_HN1D-NJCaqD?ZDKhuE#NOS}vNfM133d9QK)I+fW=jb{h+s zVNzhoSwzMNgNgwjUO2X*Y%5Y$Y`TKqy#lg>7|P~*q``jf&h0B|?gUFRJ0z=VT+31h zNdr1P$8)Ci>PScO$I3BCnmxKd95~=4)i5MWcJ{u3yR^B@t0#8syGu}{!hWU0Xu1=i z4UO!QD#9tDz{^4rR(9t#M>EC@maa$es4hGz914E>r z{R$9j@pp#k1FaNAShZ>z7Z~T+lNd2XYh&+rK&lkTB@cM`x=UESuZYkZ4ABz zbnu|I(}MSTqwfmaT1nvPv`^dwF7p)X7t;6hW##7(yl?T!V^J|6s`A+E7^xR+)zZ|R z*c(6;-I-+`mX@MTH&2sFR9Y>E=R{X;$ zdG@M3uw)wrmJTC=97m^gs6+qM+-?XW&(dMVAw0|{g938HkTzG<=FX`Ui9#pWtT*QZ z^#}woO>M$15%+!?bPl0lP$dC`ekl|~-G#K#4qosmaGqzXq!?+cPbjEA?Xy0Zr-y^B z8zDXKMC+MpvEFn~<=_cyV61dc&JgrvyJYL=`55)5Kn%?;EwU2|UHCVj{ZHj!_TPo; zJ4*u|4vLq0j``#|5Q1Lv9#Qv) zVTvyZ(bwujcp<6y1|eD>0{W7^%@Zo3IML}66_-~8ao|LxU72iiJTQ3+`!*ii$P9J^ zIY3)!K!Vhzc+^#7w3=$8#_&%nxH=G@<_Ci>{@zNe(Sh5z;3z$GDjoS{p3)w`Dd`rh zF4?~w=`hLRNd?8Cz@M9%<+p{46*bHd$CFJNRk%OS!;A` zL}AjrE9vSGRP%MYAPNJJy_h7?h4sNC><;qSFG(QWidd&)=?Yw?WGUAhJIj(Kc%Uqn zU=1m>hf$PMe5E^P{%?eph2RuWxV2}(-ihY3c7n7YfHgF$9v3k zq!j9!g{~kPX>AJ?7Z-mcrPm>)xp}0tHgoMnFf30?5;pu3GkH>b*m;|8OMFN8{hrkx zhx`W^zaAxBwFCG5;W5~!*R!9-NWX%lJT(@3oZ&{7G@?`|uzSYwW|%NeO6XYjGhZ5M zh7Fd{E8iP;jKh(DyZMT&y%TAbAC!*cggjQ9E^X=f%5P|Vt|FE9=Iviucm}|K$ucse z;PJCDYzvjr{S+n?^v1xFf!S$>I4GDM4|Fnja^$ZBL~}q0M-iNsc{=y&Y_0KJ;aSt@ z%#LPAskC(}U6Lmhgc>~1P$&y?P>yY-{7Y=YELr+bRAi8v1&z&x|0Kqm~@ zQt0b+H259JU~yR};Ztlr0zx-6pyGU6=%&7Kq1B{b!B6Q5h}`fqpvyTC1Fg_mQk2ts zn60!ku&Qd-l!c9JCUcx5jhgr<4~Upm9!TwX9ILsd^p`yv-}%wnvZDy!MZib2k}4AL zB@}#QiJH3?P!MpWgf9*?jXl|pNz#bO&p$?dkJn3LAcW>DCWz{SMAgXs+*ZO*;C_X1 zvrG4%-~c_LIWw`0mLgab$$!^TaOx^!KKu!=I$2(3=P z1ONz`0Gq4ko+=H*8JKaZG))K5KpxYv>d&92VZ@_oNiM!;y5x@sE6XYDq&ci34|8Ql zrb|)4{6D5kfqinmCbZIsd^2%1QQO5DAiG6lRY|q7swB^l>UDuEC|erY5$L97q7{!M z{J|LmYT2@EDc&!;-rBW)wxaM=XMjJ$^=J=|?1}9AY^i6j9$0^@5=YJf*J>K~e+Oj0 z44S~A{BNS+HccE6GbK-qs^pnc5V~dFOlg6${$i`CU~vVV3!<$q&6I+Z4_uEI)Xl5^ zq(c&t$RxSy?UCm!>Q36X-LPZ;3-p|0BTfB;vjMqu#>!sKwQS_|OqnY^?p}|s z1+GB)ioGGGpgiGJW!`YMeXexc&h$Aeo+q6Rt$2ixHXlb2`>J0Sea65Vh$q?gqG%3B-5MffGw&UUgwQ z&*H2V;PWj8Z>DFgum#`lGw{r)6hy~rJk5fMS&P?EFnKUjy<1K_TE@QnPk^-ZM ze=rAhjK)8>XBn_`JSBSr$*kD87Fp0CT2>v6>JG7vYxm%A#2&0u4&HWs9VH#cWb55ymbpl7?vC;EsG)s_qb9k|dmobNk^I zBwAg4SQ@Sy!}=9SsZOVN13Xrb)`Qz)*y9CKg!`1oEJG0fwR~31Fn(SjmFqemqgr9v zXrMESlPHNA%;qeX!gVcd<6>!4r#nbmQC38u@3xuYR6r5% zOrxCWD0+m|Ra-`fCZO#fk@|^TkbfoH^@ubX`qDcTNpm$p`0Ex_+I52vftH?W`zY`&3bb;KT=sA5 zRNV?$4tR|ZdTKn6ikmYDbMrvd-3p`_Ar)n$_D($xo`jml2MErucdg^MSlJROOyr#d zUZ5qo3fN$5S|a7>aH~CGnbgO%FGg8=OPJVG%cMn0(O#`SzZspEON;Hq8wOM;f|VCb z@w%Pt%VNoU#IO62*>je{T<+4Cfx1`w1-YCN$?dQ%TZwdK!ApTLTF9%q|tUqxVye(-B#$?@Ffw9L5Wc}b`9J3zj1PDi=r zHu!aNxo=KLhUGQOxNnPe!BN@qE(aj&Hop3rRH+MI^FfkuIiNN{f2ax{T}tV0Oo20P zKb#Uil8tlUkgDw*QQhSo4DK%!jW9;;knXh$F?)Pigb({~F57{)ylqGgahiSdXE2Aj zfpJ(LZ`|;X^s1dM-Z=POX$aYic4HT$t2VCPBmE#-V7}iv!dUPjb`_pxnD7A1I>4+m z=-&pIw-4fuL{_VL+3Sqss--s^@IL>K!;)|Bm@hC`H6gyJ{Oe!ARirnJ3Ioetd0gP- z&ghC(L_t`DG4_bmQ4i4o8J|fn>ejRCpGjlGy-p%UjoJa{gpHdps!NxK=?a}{6ZN}J zB?*nCnvY$f0-r#(;B%?FXDb4bV()E8*h@roy*co$&#_GmWG6odQ$Utc=1 z)JgNjF!vt-j1F)Brr>*g6D3-@w8);PJ@6xMZRE*%ehVO{*tl<{64$!(RAKq`3uHO% zFgAQErFZO~c9Ci$Uuh=Gm&SBsB>`KJMWu|>XI$gJ;`D2pctkfgt5Ir{-EY8^=oDzo z{6)H;w-egfy;mh4_cecj7CRC7X?c1?`KYKVH2@H1oO@OJQ>P0w&bfvI0LN1f$%G4u zPR+(Qf5#P$TyTd#$*b6xI(fCM*8#&2$fnxKLu5g7RkIiD9WD%AMK6qPz<%i6N4l;u;5% z(FFb{uL|GC_8y93%OrV=ZimrZmghNiSmvHA7@R_CN9Z@Qb1p++6OPs=RM$K2;?85I9roa(espzx&au}a@K`+MA(7)TPgZmA$Ur)CC9=Y3)^M8r>k;Ro(RGkqZy&QU zFM9Y2fTskva4(~!SSKe+w3m3>MZ~q3n(BWXbkwwducCM)@ND<>y#4WdKmUN$d zqGJMWTreE_VaG6G;$Eme=`~!w8k+F&NY6mvOxjL7Nq#H1-z@lzCcj1GHA=2e(?VGh95vh^e6_1@uQl7*0Q$wEBr6);X? z5e;UBaY(HEr4u?s9xFGBy-Q|L+4a@jk~e4bnq`-$pe8i}kV7ef)pB)Rf-5k;K3P`<8*( zcG}8h;c=K#Fddj$AP4m*C{Cu+AJQC+fo!SQNMk;#n-;jk>)rSQ7GSolOb3G zeA?q}S$20k9>IrwRVe#tk@>f$O^S#WmJ|*gGEd>f(iY3XSV$gTET5G+tU__MQCrU@ zuaGmkY+PeIC>vj+5i8}fLo4Jk%sjuYkb8C3ueObHc|@(0%6b*cJ@IfhqgZYMPey8q zyvQ{L=ye7QntO%Qu6?so*cT;ocWG(`M(eO_5QhHR z{5%>u0R30Bj@-Wb7g@zBc|o^=jqtx0{;zMsNB`1gA$nSIF>N!rgYePD{LAF-jvJqY zTLPpkucpDcDh5x1y9NY?6L4vJ|&Ne45`EfGc_dU zv_lxa>Qh4k>*L{?8WMHdAzbqbGy4oZ9Ul@>?;L0hcv|j^>7GSyl*jx}05AXuV`n$Y zbG&@tP;*8Ii24DO5e*mPqLX0z#T*pdleV@fRFbURIt6|!O01J=cNlli9G>Ahqj zV`i+dEDh;kmjFfsO!A~yLCi>>oEDe09z`4@NM;w6pH%+{f&&l5b!2tZU+R#L3~c|h z;f{gFU+Q%6{r|l>?EoyxL4wl<|GZ8ev^volLU9h269QLwJ@}~tRpjo&PMc$^{ZhZF@`Da}h`4J#@=ZdGR(WVt~X?wwME~wYpJFm$n zKpC!lUA_brs&n3u!+qa>sKvDMkegl*%q$u0)w#)bz9D6QD;PFXge^I!%*|c-Hv9~hSr&Un?Z9BQEM7QHfSTav=2qsJ>0dDqNnY>g3x`k z(UNjGQr4JE?1wkyu;R@s4n(U>p&QNidb7ROY_BoftIT$Z*=*=BpHW*3KMnLRShcAD8vHQUK%JKk)^nC+ovdoZ`n$A7m_NlTN(pbe~BT%n2@ z=sa-5qRx$ibu~u)4mm_eyaT282?Y`arFtxA!Opl`EFG2#UtCjFlC9o(ki56icVz~C zTKc5%->DS%F#^j)?*DOvo%$Y}JSM>$WC7II;9*UTM-$8ZVqzat0f5?J9oa;h7OmYYpKRN>sT zJa+sY*?*>X`|gkhzrxO?!zhAW>$ig2fxb1 zwNooyJ*BA=kgoI)cwNS)A&jN%lmpxetU1vUN<=xa(w%aTzZYxYPPsd=VLv+_+jDXGIa9oJ@SC!G+uCX7Y|1eDp%9^)N1sM^@RYs_={3>vHp|xE_UmH zN^L_lwd>ZVyO!122#tHL!#K8D1H_8*bAfoHe%wsLT*gH@K z3@2T8dH}I+80Dq^ENpd^yz`%hjoK^E^x`lJkGbyr(%zYXRz!KZ?i>iHhxS4@Oym-3 zBJ#JknwtH$R{I)W)>hkshM`tVM&H*oCbB2@$zB7#u(p=TAs*1Iu}>kOrqN|3Pyv^2 zbUjAFx|)mZ^gcPDr@l5>=;$& z@BRI9H)RWa=}zVfJ4e1wOm_elvO6GmouVR;vM7N~_g-WNn(Z*yBzJHy>;v%6hAkgW z7S@<;VkRNE;GlL$OaonnqtULHYuNQEd**=bKd=r7s4d;gs4Y7cqm`OCsiRR!VC!pF z2Da6l)Q2@5ko{bPKh=_cvWk*cGmj7Dq2ANrSqQTh=6x8q&oDv33}^E`lpoMtXJ39O z_tw?2+aJn(At$uwL3yZd3Y&dU-ewp1G<&F84wAeK@sH_MM;7^!9H!(HU^dfNsi)a2 zII&l+_(<+&SMn5(%6|Mv7QycQ6UBV*VJ&8N=2?xHD_Kl6=GQM+KDoBDXJIL(MOvJP z*=OYYCA(fNPe7qYek}X-pM<~){bo%%y9Z%_x&pIq=^=fbDK$i2czlAP)*L9Hxz(9$ z^T%@V9FfD^tS-Sc0-iX1NSZ;y{ggv=R@)*6RRyW~7og4>P{VJw@v0Hepx>-UaVTSY z-&husXdAwj1$`n9>mQ7^rn#Z@OUv9~i1Sj95`7I#9KMMYD&oA%Wh87<=dmY0k-MfW zMZZ?W=?$Z0JaJorBa(_Zd7t}NR0$s9v@ehx8E_nla}#!hd&9hHnvfCU$E6k2$rsq~ zpU6Xf$74RGQaq1DmKhVTlMP8;pw~y%V09~EIW=-n(#wcIsbhKSm?FY1P!>c?bEO~< zcHfBO^Lj&Ep!x(zZmL8GRU*)~65;HN8o58z!kB8%X&x->5C+H%mV8JK?m=TtEyVPh zIJWRCf%zCjRdU*2Amp+QhvY@NAxwYRl4dWESxe)kI+)Yk)pR@9=)0{B1{zkhKh9;gx8GYkKjP6dl&|x zI>OwwD^FP(wfqI}7MRLEoQmJdLn&;1Eh1;LH)?TOlfq8c%Kd`Be3W{kJYj1^!bY_m zq*`slE}DwSZx2+(sBg27qjH~KJco5y4y_%#2H8}UQ3eJN9_qx0@np92s2tM&-24{s zD^?`Bn=4H7kQxt)38Ml2t7(og2ho&++vvKZvPVb$?V?39Bzmby?B-GQRS(wXQ`vur zj3&op@6tbnWv-Aea8i971%}g9c+HTQr#7Owprp-<^35{?r^!)W%O3nx-YoGl{8r9B zIxlzW#&bFjfG7}2chQ*QY>TvqC444NgqXt@K0`M;&PCq($LJt^9Zig7pJIfLqY>J~ zj(;XUjgw(J9i|Id_36zdNsk%>I~M zi9_F4jsbH9v2TybJ%?2-MiOHBksUJ79qJnFgNbnm|4X>XLh``f{!_CM92@<~vRZ50 z9cicz&FZU|K5H7cv;JSoc~KXT<6X$n1v3MU_`;tp$XT-7O(=+~D5IyphRiB;GdupJ zJPCue_gAuC4DYwMfKk*v35V2+j{*I$vAQRwyvz+LB5y+8kv{tR3I}!cEEG*|G-Mts zJApn~M13-Zt@%oR7`Wc{6~scrF3|f!8)w04C6OPF?4W?`p)~h+V@4P%I@>7sV z8`;Bk@>tzLR#PXR*D?0$ae0s<&N1<@5+#_xem*WgjT3~WC*)u!c)OOJMF&*!`|^Yw@AM7`jcEM_yt2T6^FJvkW2DVFDQCf|J}LhQ{W)7t$sVIQF5ZVm;q_}! zA6brMO)ESnR3tRmBB75Z%0)G!J<3JfD6K1)-Pdw&?`?T}$d#p`X6A6-gS%Pc*YZAj zGiv{yu4=nc{zmqYc4nm0_3?s5;v4gsX4f#$UtQ*S~eJ9T?K0vM8Mx&(cA{L0*24^it)%_9} z^%CTYO?<9!=5xhaT5HRw57Y+%*@{fd0HlJa*R)a{noW4bUx#nvpHw;M<{-?h!fH@a z#u5C{*)1OU<{4;{kr$T3n#S2|;Td_c^87pv`5M`8XMhgb%;&7!(=Sa;7Iwho!8`)< z7)%AsW|(bk=2>}cC-gG(pnh2Z2HM2IK!5cC<0oga69XUKuiwj!I&|u{Kgv8Z?Yuliew}c zx|_LN!qojNqPD}ajaO`py@a0X5;+>ce4jR~a4$2Vm`PO3fYI#uPqK%XYz{lfYhew( z#_E2OyLf$f7`3Vif`{gtX{8{$Y8tDKVX8nGNP5xQlFQE_C zcpOV%zADC23d>YM3%tx$sIoW6jm@e&-09q8;IDu?1KMro8&ogSco%!|Z+ zIhf6ClmmR8_h003x)fv4FY>*14%iH-U5&;oa*G|xzw;{A zkumJ*Re50dEpaFx)=V=fJ~OX@U%CE0>a-GSQ6l)7WM8|KPkxLyq=%kw?D*B9Q`bPN3-V zY{LyX(1kXms*5?g!allz{T5K?1_lC%^qcY#4>xUeg!RgQIa#R{Y1ycCs(r;ZK1g-g@9EbErM z3h%VPzlD)DhPB+1!(E4qJUjK3B+6(T8*p3hCSLD_Cw{aZz6@7PN#kXZIS6NCi zZ(gWFd$U&&dC1jdpC*`J94i3 z3yxIbE83bqAEUUYF@deWBS+{iu#fNH5;cW=eMb&=a_^8roMa1N>Db31&M|DXN%l^e z?V2L&gI^8I_b@?DDMBPn0?b61xiC#INzN(4B$)Xy%VC~`sf5|;k|Mkh(~<2ofhQ%4 zePNQLL{5nOut`#GY4h}TChC-)x(zHsr#y}A*dd)Vz@5{fe~z;*XEAwdBy+S=Lh!Do zpPjN`c2ot$_dl)rV>mc@nz2aTm)6If%CWlNbvuOJL7_qF_6@f@K zjqjoVEaz1eRadhH{{%)+F3=EkF3aANjmfol z#)Qq)1btfv%|TqKdN)`l_aiv)xSbOo^l$}14Y~Ff1woFXB>6j`Xl_9ko1vg?X3afY z6hO{krg-GCaIU>Wab`XjAaAG+>C!$h&_+U*XS>@A-y>n7FiA*7PSozOA)5R$QV>zclqqHvls0D zG#xPQGx_#N5!`yE2*(h*7G?)bHd5rmybhye45R^+Fbmy;=9Lsa$jC{(ku?%|XhW>0 zuoY@IW5Nc)YVy;i`R0ioPlx$>`k(wSe-Lgj%DnI z^Ie0>-$m)BQ(3Hw68tw!T|xgyQ`fC*dm3}a_vyVA(lH|UOcB3qbuTWtpl2l zuF(a0M_V0Ttck#xM{U|N#jUu=uYEw$01d|iWBHTu-35j&E4M0fe;c5_`3cqmIv5Dq zhQ?@yUjwPP>>kGls4oWTKU&Blg5rd=^An1NHS-gMtULh1;9C!cF3p)(5obU-j9Ky2 z|I|H8wY)nus8QkfxNx1O(#uxDB4Asju{zqAB0M}{G6Ow+9DM0 z&w@KC9z&=Rt~kaCJ+yHl;6b*9C1-pnXg8}k=?B`N;S|erOIQ2i2 zI(OFCNeLSs4q&Q_9Rvr}m+uZi)76#&Qv^3Gg5|qUp>1pN+8h^bSPeB8LvxZgFF zltH>5*^3^^SlyHCHxH%I%R8{egeSLI(fcVL^r-J9duttA+68gz*zPXMGtyct9C+5w z(ma(yNycPJj$@w6Y_CNDEjEG>20sch1)t+YZzvn-r7U$0!vupuXAeS4gtHS~N`Jds z{>;H!>8?A+!o9J6y~@UVD;qkeVlu1%XW?EVp|8I(y;48Xc-KMa%a*k(VakLx)e z29Z8I3?hB}lo`EGdux4XSiJ@vK)W&Z-Y)Pmb3Z-RVfY`VWPq?6YVcqbP48CVQT zDMfm&7kk5B**f$g;F4BS6pc50kY{_rE(bJzKslk*C6o-D6`uiy`o1r=4SH4_X|s4O?47{mKh;V_FfXd$wg5MO%5E+~t|g6#0A8P1D&2 zH-A5^;rZ_q8tOw2ae(!3$n_3Z=mqW2cOZdUOF!>Lv=n1sxbi0sK9RsvJj3mkKa&qZ zFR?(c1Hd{9^rO!k^e>c9R2;CoZ=$aXC(+NQ&-E>)K7fK6 zpE{Fps(xS=+uu#`?zHvq{y%k7dUneByMIuK5>cEFu+ld56yB*4G_^D0;XY4m^m3_^ zLdrE)=~aDV;R!0@6|IP>R>X^15zq1>W?nILs#whn=FWS>kf|CR%bgBWT*F8`zRu!{ z-cq4H7aeL78mhLluS1l6Sfw38G1j4?BUA|}KH9&1Q8_RmMc6VhMfe8xlqk(V2ktds ziXh1a|A9)me^;Yi@!z&f|9ADl4A-_x|6}cj?A`8)M~A6s#8qgduEHYY@$SlMom(}U zO(v}_q>IO2$YpcF6u(((holIeW^G<+a~~)uT$IBV2$8BzUtv#lis11NLNoK-h326t zf-_ec6uYp9+wQ{P;qc4Mp9P&!=2Tun^Kka=&x*U=OVGzW(^KhUwW2dc zu>KWv#57aog~m{~!mF&h_*?P_A&)1y#|mGo#|n5rAOrx>6sCTTnY%KTXA0iK%w|^D zOYw)GfQ`L?+BnVVrF3(RAV5uBaRU~K)iImh?1cl5nJlok67Cv9VFp?gG8-zdoMKaY zD~m*)z>%Hot@LrBzErRG;71|*vYAV`vN(YIE!6xXs|`<6U$-B_`?GD~O23{mAme&t zA1HD`_3)sBjVo%SJK0Uzk&pmSyg+AvgeyPl?q_HED1H#Ca;uLLG9e(O#e`$(Qi5zg zrsA2_fX1PdY9658!s%G@U$f73KxIa^(iK5z7LsFbHb?)AJ=_=5?^EopzKWk+tDb$< zS6Ql6<{jh*xPPzAG&ZZB@@S{$fp6wzb$1ki=I&uv`zan{55d186B*>fQ+2^Hr>U?h zw+_C!XL-;S+$6Q&0Mk@>C0C2AVm?(baxXQvi6Y@lkn|R)CU=$|q4afsnR}{Q%gydc zjRYaH5jdWj!g}^sdV3y|P(=umkAWb{R<(NvTHrHtUtseQ*!u}fAcQYBs}~&!$65u~ zb&E0261KUnBWb~u;8*r>ev@BVg-R$ZEg z)hW(Yvw_B~QOXzzF|I}{ks7)k2g!oo*q6Z~hAO>_S0-B;-{jDQg~7V^twBId<76!1 z7K(&|bu|s}xBWXb5+^$;DZ&KU^tT=`rojDCxd_*}F6VEQzXSm|+;f3$Y zaLjV12pTQuI@~EhNS)#{DuklV6fwE=t-zXJ1No`A(xtLup!dF5JlqC{78Pcl16tcL$2R6#a6_-K?dS6z=E{7=O@~*{MYir znlA`O=qP8OKY-hpIos31;{2Qi)E^eccx!1)4z0GMLKsb>;{5IQQ9;4Fnk@KR{!+)J z2ph+y2-9Ipu<36h?4kc+R22W0nw$Sy(x&*o)ZF~vjtUkV3j(5OEOQ#Cc(FyX%7%`6 z&}3G!#!FZ;o>LoM?!x-GH+&n!h(XFMRLZNoJVL7 zIPeidBnXimG-8PCFjP}dN!D1@kG|~rI3-h(!ZKmk82!K2fAiiaareLtq z!r%5UYa$NyGgE}a6Ey!`aL4}(WV{;}|GzjzcM^u6jm%T@p4XLNb|*!t=~4pEzhYih z7RSqOu0nN|4Z?PWa3|V1CMi{K5iHXpMInrGyS3)JqSw=n-vP5=|uQdj!2oKZMXNn>k9DG_ouz=G*0k5!LShFe@4nUt#ZbDxMXD-OMT zgK)^eMy4t|z=740szd?T!bdAl!a6V-N2%$o`xs?~`{Btp^LQMvsix77RgF=S`h-qt z$2{2<^TH8;J*e-=+*t-+%(}sF1g?eLDDCmc1M);rBNL7zC`VVHR?{?MinPPTXA$C?Zze4&#)GT>{Z` zf5rHS=^W!jU4>MHTBqpFLMxn39OL729*A2wE5{u;|L!=Yb6iz+ir_-*{O~l>GIEC5 zt^eD^Y^bIl!=!AELH+5=r18oq-DQ?OUg-t-2`k1c>HU94G%LP$xk{MZq*@nsVzeiU zVIIzLHK9o#F}rl7x6X(4O~*y@JT@_18RdCo1_5bSyZ;6p1aaXHyQa~X?M(-X{Sx~I zDLU>!`PFZlZenKu7J@c)5bKnoe%!-9kRq&u-4QnZ9flqD|4-jdiNaAx#vl4? zqHwHFlCZ-)Nhs+DAv{1|7v4_vXk>>Q%bkGp;V)VF1Z7pwp;D#d1&BR5=fQ;llbPR1Xn?x| zx%qiZX1=#@g}pXW3F=pnshxMwtWV@Rtpr6g;y58foeYep0g{xnfKb4fwM&br5mM6_ z#VWIuk)dl!Vg$ANcZ!>tI}oj5&Z(59N3|AX3FjZoZIaT*GZmq^S@@|a+k&%KE!R7j zS;izZZx$<@qzu$8VQ)=R0(>)QFOh4LV6!#BeD>2MP*Yh4R*R!SIYIcQ{-GF9;*1y81kyV9syMNhI7QDrt2}V< zKwGD0cu~OfJzWV9^MSZ(1xuT*bPHUCZ&P7g?pD~=wm6EGf_yPBscvUaPge%J?Bb#3 zRw-hqrz<{QTB{(b7HDpg#GhF4RK=rzLB(n>suZTh*7Il{`y*2ODZ&g6&b;A!1Hm=_ zhrMr)uj%Oi-X}NNd*dYJeiH;i5ciNEnSC}<>>Jvag2+YrfmEHxZy-12N~16Tv=VPv24%NS*$Kb$$`4rkN#cO+ zoC5k*sdRgHmYHtNZBF?~b3iwQnJ)_keZ=0HB(`%^!9+-E17*Y7so2k7Yk8ZHRx0;m zy;8(x{{Y2G*H>6hir6Kx?RBEk9f(|sh1R2`2i72qMFkw4w`nU2o<_~vZd2)gWxu3g zY4LsLIawTv!)Vhciyig5sT`<)Zr2E<3wwJq2z?~0n=H188=Pq=x}%@%*pdhj>|9*1 zjxFS^E1v|oy_gh><8%G9v*&_l1Pu0qFpkZdB96>G0dFVOJ83~ys%{+I!CBVfC}PfF zVLl%7Zxp_#;wiB&aPDdXM$ zH{FeYrsR}W8C_4u=^yECH2ftRI!>7Cq#>7Fc|+6Ps8Rm0?#8(r(AU7@_G7eAeHA#@ zpvQqH1JAna(ZU@!To`pPTBs$QpQ43`U4w<=ccX>vi2wB81`FeMfSscBt9L^(;?;>N zWPMUa&q3V)+5wb?yqV(D=VfCZ9?LpZ@mM0Kw$p&rG?SJga!6r-MrF^<=xn1e)ql45 ztiDuPsu&@bdBq5@yKWlC`VDdL6T87V1x_#a?QGFcyZ~n^oU7TMNC#i;JC*x>2;@dv zPWKnGz*l!bgX{?FpD8xAQNL=G<q|0>C6Q_Ze%op9+ z#Ob0lHj2`wLyzOi5VVG!VA{#nP8WTmj)Mvd;k@#ZRdFj4b>^!Un<%xOz6i30UmiVv zfwJQ1+6YK#1@U}DVDI58Bi?w z;N;{C4H8=a(3DCh#@kyoxZ-AtW(_WuF;f)Hx+O(3ExIL*dyuXQTd8?FtrLXj9ylT(eZzqVbF~T z<1{@185(OTj(4!I7QZaf zbBwKSnU6)cEE{|@4-rN@6QRaVs0RN_>?8>6qxBrlKH}-sjm@3Ib=26LdhDZYj@a@q z%4x0tk#ZUgt=8iqno3&YT&|Kf4Zi{c%{G@6wn1{wlT;^FB z$;l!1qN5EL89NUgLem3XJkQESw#~D05pWtuXKf;-DylW^`d4Pcq-;?FuOMAD7LpBp zQI&_d^swly(FV23Ogvb>D|U`-QMTB?tgN;rTXex$oe#4yaO`JCv&A;KkxQ(c1#}@S zTWWPr!uM=EVA4X(@Kd)X|fMR3!}kJ{;_T;bg_XC)zbeur*Zh^|1O_wDI@tL zMsQnio5pqAz(6;GN!(mlpX)$HmADRg zget={^Z*;en45r!yT*p5&lkNlsV4BBF%oYZxx|y5oR2=mg%eM9Z@$-Oq#iYboVId^2GPY&GKVTsLO1srB#ok-opEp=|10_4ef?pC_Xsl$| zOPrN()$N5Z{R{2ZHqY{tt0`7~a{DDKKheKzgq z5IA7Ypd6%u(;wW_^f-KD5wP0eba3=aOo@ZPdSHU}n+l~V`+Omm`9`tJ3q@b&-d|(> z>46pfrwc{TcE03l41>N?Dae6iNTLCPY(Me<*3xjT19|b-wz7VU#Qv^JR+%Sb(Bi~w zcpY222z&cC*@uh7mbrmQk~B-eiB!YP%1}V6#?zAH&2oH=#Hq}KTM&nG14-q0lE*jj zpe3H21RjNitGu{9D~UXJQ7C6xcbtz2rzr>b)zm;k!ceZ(i5{_VWGB*5V8a%RUT%em z$1?ZNLwM})vzHf(6MR~&HfMf@PMM7r1XOKnFDd7rux5E;oO@uAIp@%@a|C0+3WA<3&Vy!z z3)_>2oFuc;d7^KpUIufvKNM~EU~vi1X|Ikag-Zn6#J*lXNee+yKjv-c5Fs> zEmJ(UpxiOFtAxS^YAb&RY=eDX*z-AU4ED-p=!@iqjnDBN2}fhph~apCrJccEUA-BP zN~?Ol2zrn9N@_#WGpSK3Q4P4Osu4las6zp+@*t1X@Gvwvj^-q0r%a{_2lycSehE~e z)>`sKz<^d5_sX&xafHp#&Rl>$(w(taUZiyJRiQlkf^w=%K)i{t+%^jD$g$z4ai4Pe z!4rs1xd4Q!ETDvIC|&Ue1~jDXl{Olz8Nu4;o{mE`Zlm%<8qT6#Zt(=~0C66w017n9 zLsYlHlKqvSA9(%YT06q^=6bmQ{du1-77zFDCmO_3AK$W|xYZ?{V)Wh6cBoqsE zl>hkyQ(iv-8I-AcYm~)6w@}JP1ffRS(-H=L)cUSf5-7EX_$#lBD@EMbEa(S;P6`ry z$!92H#^o{W!+fzoH-TZSWeZIp#chl!)`qcE9Z+CoRw&wVdJza(_xPAeoIUra)|?FT^NL>q+Ad zQHId{3$TF$BmpzuVc1(u)q9nX2C7(E1Cj=U=7 ziITyZFBd(AM!h;%XooQLOvLw2JSXtn!P5{h=zOe7exhy+LX(7!;l2Cj1Jl9z-0voK z0H?!QL>y z$ZV}abj#)52Q_b^iL_{ITzj#w$m9ADH$#}?D$SDyG z41EvIh<#Nkm!Q_C+-Dn$ z#DMN&(WD2%fQ7*jwB!pX*eMbDRI~!=1lGKQPPz|&MH`4jz_6CGsv@ziK9q;5Q}(0t z;fN<|`HHxxSqNcQ6(MMa5=h_I@Llwp7IGK+;uWkSb!C;Wh~4$QU#Dd2ln?e&1Up!V zHP~AGmW^5?4iDnX)DGxpw7s%zi@6k};a68w#Mhup**9w-+hwxqHDU{|BfwFPe*D0c z-NI0?o5s7-1lh;h6^k9BUck4yqOEMG#GRw!j`9(z(O_H#N1pz;QbTnp*7CmXv~?4T1_;aahG&r>KG&gNfN zj^e{`dH^cakVlmExN@y=JBc+(EQMTuSvMHJQXYf|w_W3yfpgPWJbi_~SYEg&c(c2UCGeo71+<(19Y zC$EXkr}3Uu_>S7~h(r&J!vYH~Pn-rl_X?#2?u9XTsmU4^(e!~VTdX=<@MFe`(6ETc z4-{%xtj{{JLYH84SdXQCx1_fyYo#h<+mH4vuY83K+#q(*-@u}hM)e@C!K`otHrmSA z`y0g8PPOn;oZ0ye;s9ME=EcN-4r9T?498KUYJFB=M5yXKkQyQqKH;^wxEiH)Rdg8k z&mx{oI+^^8`qpsQezKtxF z4NObptV09iu3k2M6V!9Zu_v3v_~0qn6rk?51RMin00^O~S~UcW6>{r&tsX3MGZZ6T zu-aa@9IHn{(FQE}P`^L96q#SX432|-@Ktiy?#*HpNWEsW*rxSwB;Iju#re`G5+as! zvL3=e`N$l}`oAuE!0yoK*TtaRZHNVW(uhz=M#bpYmpu=2!6p+CTf2_!xblISAP&8u z5*J0D)(u+#+7Ph+G}56V;3FIAS)(CS@@bJ)UKsPeC|E z1;xY|Q7MA*EqBwtn#ShhK(wGA&?xXa$SW#lW+r=VmrM|x%YAuJ@`R(Eu+!oO3 z9kE5H(R)$Li%|^)Ww|&5QCm8d0JAs%f;ReIxss2Ht9pTWge%K?M@$|CgR;uy1IPn6 zi#(sMpFfVX4N9{OHoPDV5s_KmQ?FB9Ur;LeTa(SMa)(yCr{Umxw(p9ujlV@OjXzYt zj!5piVh^{!^QbiJE*!fd`|4eBcJBCnW^9vVpzY4)RCttEE?$Rr&}@g2x32sU;I_YI zA7jmFKTf&eO}|Na)8_ks^wR&C){K)d6LnNe9ZO(PdK~Yv18$3cmzPk+n!hi4x*rF$ zzD`(U;Q~u|U-Swljh4LmgN2$r^`sAYGPMJg(TC+^LkSW~XVgx9tmu7lac<{NtZf`@ z+s0w=0Nt#$wlR6@%8LQF{ka^#St#RRA*ED>-@=2O|5+P17Jf$^X>DBiH}Skn zH`Jj`8yB-#J4H{sZ3nn^lf93ygT1j+^w!q^t${^PDwrMJDYofEN=%X8s)xBqvpRm4 zdYFsa1v}L-^DT$DsO9{a?}uVQOXz6ZMdQA&<_@DDxvQJi>#G`%v`4 z7?ty(_%wIZK`WJn+EU3jc$8NTD6&!sdF#q+0k{3_JcNnpr-Owkyy>?FZ_@Ml50(5g zDrq2WMjcr>K?~Mox7eZE2>_kPXhfhFgwJd!$4&5pvp!q!5`sVDWW-kN78^Au=0Ljl zL^aeV;0k1ndCJ_(j0|csKlbr%@ud#Qh({eKa082Ndyj)hdFAp|*7goN&&KV+8bBxZ z>K|JKMHb{1fqP-6ziWxRZu>3TP?$;JGsB?|-$*xxezdvBiFIiq2!+bc^SO zqh`+*?DdbuaE}&Nzbh8MGwjaCVuZ)(X_jy|Eq=MI?XT7z5j`r=wV8= zgsZmr?P7YPILu?S)vw0lH<)D`#eNi;n+3Jd*!=+XI!5GEon!vt5T-<KGnFo(ZaFUW8ryoF)ivbG~yIOpJ^3b2}Wf5=(?F zv2=q61g|_Rv5>c}d^O;2-$ zbM8ET@YqWTxd``I=k>utQ)u6&&c!k3dbvDziw-ykkNX9gQAaf! zZ@rLr2L(-?s;1~8Y+-A^5WPE{0Mr$>=KIf!PMwyLlaZ~R?5qA2C;RA>hfN%w7-uhj zA-3*9=b?)SL|M*A6SFiQTB6~#`h5(yJ8^9iPLS|ZBN41~nds(5bnW+LtS~`vLRk}1 zaGGr@8&f7WYq<=q1+(~FX%%`BzCqjqS-8>ginqg3W~PJW4y){-7*fEvx_^JNAqBspSYMtxP?3V!Dq3X!QC&8 zWqc`43+e+ZP}zIe%TaW|uUrYoDn3pXV_JVO3BJlN?7^2}VDrZ4ycP}}4G+t#>Ii16 z<&|4m&%@yQ2`u9F?wcV6TN08b$BQ37|{iks^l!($1sAApq&mq*6s zeD+LfHWO-c%}Te8CH3#^A2?vYaN5mJ~CY_yR2<~|;ye(_W#t0fa};9Z1orh&@rfgq z8g~j*h`IXIvlLyOlKT=xw}_2CCbsjj1IN*(qm-jMP%O@L&k$hjWy>)v#dd=~?Kn_( zQ3@6z?=g3vCLPB9eoPE_4n&QcSvhf2C96AjA02sQQVD*Mlc^CAKJCYC;!rOw1ih^x z7Fql#gjXCJa$M}#hpNqDmACgyB<-+N*|idju+LC(0Q{bzyaYC9yfO!C{ zblVd2?dVn?V zN9nwFaPNy5%)71bM|SNiv7eCzz$HeNQcc*hj}o)Tv)#JT z>_OSnLh#O;Y4)(`qE5Vzj$&_rEylQsoS<&11Z4tEmsegi)_sj#l(Cd|x}GA9YSRF* z(crK{F%@9hwpw3g1OZyR2}el-N_e*&i#l8Bfx{Ekpgb;K-Aho!c)HfTAoH4AUP#lAc#dU*Uf3;pyLv!!26 zf53y?{Yx@CnfobmSpB47^8A!Iic^Rs=_(RF>nH7kN`#&pC<%`YEko5}Pcq zJjz_Y6@9S(-~L;%Kc{l4US1^w5vjp#w?RGP@+YodwN@@iXl+KIGgitKAcS|v;I;c( z(Stg#e%)b1{!~g$JH>I#G3`A2;akyP?|DV#GbiUz<9@@W(_&G}dX?!18JWyC(D@d*fElGg!42S?L+^8w*MBB8RfI--&Ltj%FpD#wnD8-5kJ;7ymhl9sN#h zHlZHYx09a1`kVl-g;4#B7`@W1^g)b^F54@=Pa1-m7V8b)8rogsH2QUxepc+Nt6^`P1xJ_JCugzYHk@5QD~^yqK<(y0?WGn9Hhs>C{XO4;*hZs8 z9O#e01MucnJ6fi$t-i-u+!4b8PXN3q`GJPo zk3hXS=)MLDAy6BDRwdkDmHc2;%tK{7(~2F53_dFog%HebGc3jPij5-@_5y6B!>Y;x z$TdaD57n4EDBmR_>XXs78Tf)g2RX=`ft>_;kKO)W^zl3NJWBf=vhn4QcB-YaC6CD# z5AH^QdHV~ZSI)8xWBiJ(;9KkX#i0R+u&`1Q+5yZjr?zPw?-4yZr?}qI06sl?0PLfpTPBO ze%>P3Gx>Q1FjSZ+rh3VuYLW&Qc@-4|@~zwJ35c*?6qL-$^vk}mRaDx^re738+TI@m zgxUc_Ut12wq@GFo9^#ETiS(I0LvqKkQ^(UEKx+qT5kNa6=PK6jFu!_QlT@qWx zR{*FAK}AJ%w5vjs1W4qGpoyaO1R=R;b2}0L3h%LAzZDAQ1&mrdyORa1WH)CB9TZeZe_UqDW_pFG&Y~VCMLRO z-vM!`+k;%^YCSu2O$_uDIGC5L1bj}}9znG8Bm3i;*rLr~?n%3gs;1Gm825?_){&cb zLXjn1chS;LTJLp)L>7LjhsPslf8jkTcc+o-swnNZd5hF9k)gQ%fq8@?} zb>$z~OFxPuT`I9`K|SvY2GR1$N2A%*AEA9ult;1^pILtd_KJx{V(DmWNdmEGz^Bm= z+pLlnN6#a4w~cWH-z|(CfE-x`7Cu2pA#ZJ-!6&SV9I(XDhoV=n6>+4|2UipQgbmyC z?8BeH#1$}fWa3#ae1^cbGx;(AAYJ0xOmi8yEc8APzI*ISJ41|3(Ow1Egjj81i#aM% zvh+VpK1Mn!(*X~6*u1!XJ?!EC2pgtI0bc2_IhJQb*)fZR{zcd}w@KTReQ;Cko;&?F zGfOo&PDP$`Ch>YUxbrG*komw=N^^bOB0*LDa5mgT9U5KyLT;iXgFBzEd{1u5xWSzh z+c9#JsEnH-i1>_fTe$9QB%NDcnLP?!4!f@T9VmTW`4NC^e~~pf3i|tC;mto(cr&=e zAPW9_J1zegLmRm`*iZKFBYO-K=2yW&vCv37*PHzJ7}{_V z+SIVqeW29-&ClX#_uBikhhl38%uATWcK?DE(kqY19vIA2*{mAsg=!(ry2R=sgzDl1 zeSFHi?AW;}v$VBRPhk+CF0tuz>wz02C1$?Re|EY9H$$+nQ_O>GW2i`^SdT1Zf-T-*VLyYp}mG{|o1*~H` z3TrETaLw#8$Te2ULn2WQ;U>_#y5Pa$$WKXr0BDGn>&%IJV2a9H=w%Ab@ux&qj(=dX z@g70m713U%P_WsfI3s{9ptq0@FAH`54H=<;y?E|=vaOY37PKk!x5YjEP)bBKVZoWe8; zRur>ZT|aPTkyT=l4^Xh6qhEavwGz29X3Mb{h5BO&vbMNN^qR?SSFVh?iM6Ztj=O>V zu*%+X8Qv>nE)!JfEUj3^s7S=B~ZdSihgx-I7=u7d&eF450AN{f29$@ zCC0)7=+c&kpMRcpyoZ_nc@}d|Y#l^?*{zSE_SBWeV~*RkuTr8d%q*1+Y|TArc@ARl-xK|x zYllo*yoQg!a5TQA%HEWK!z8su3Fpj|Sff0`g+Hd8b7_-MCW|^{Je3AoK#A~#{{3;( z7|8i;w4Hyo801eWq7!W6K~HEwPpi%J2b)kWdX5CjF;0|u8#dyLNKyS-jW1d&J?2=f zeU)V3LwR-T6H^Hl&)`l)Ykyk5ItZi8fR)J#dL8vOcD!0_1Ld^pYOz^A$}W}q=t$%= z`8Y^R?QGq6`O2*2+YM8qrkpY@lSkA{+Owg*iIYgqS>&|RpZZRCcgiAM{2lI3*<1`i zdWUzXtir|LQNwa}#hMas=4_yjyaueTgpk_v(nh|$4&Nn&-<}sb^6icIrq!&C+zdq) zRdaG_38k5<{0_ZmQ%-4GF^BFip*$#8IdFg477pCaV^@xI;BF0bCr?4y$ALT3b^tSN zKS$qDLK#ptai1M&M>ueM31vcA#(~?5Vh$Z_1csu(qV|WsgAbl(6~BwYR2$)r6nf!3 zL;1rF+1yP57hdC$+LsU7^zg~s#3^`untLbQRKC1GS|2*A3~OgHrJd&KZYd#T<>ISU z$}L*nH9EOuIvvG20G0()oVn8pK#b@-`kHHNWz~IFLma0<`BW>P+nddzjdN zdp95@l*9JmQVD_?y#GAg`-d3j*OW)P@nBPm^H0db#1YQmU0(UE(WwTjY*bp|`SOuC z{h%77{JM?F^fpo6^W_*TIoyFVu$SOOmmIE{FI$VjR~_X{jtk+33x+uBAH&ymH2s5( zK*I46a7D9H8=>mTs{t2sku&oz!ZA*`X%{D~a)1YZu5f1~?f(`D>z@c%xf{P#?`7DD z%YObRC9HoUU_}c56;o#Zf{*dq1MxlGm`SKBIVxrLl++Bq6YDEv0pb>wGk0$4Y;JRU z*zAl2+9vHXcS)FbgtC$2;_m?@9MdAUoRtORoiRA3QP3gLkR zJN>OhLf){*3%Kns&pA#w*C0-a#hZQ;@&1p#Q{KN&X>b-&QAe7-(}gGEjNC17|3#z0 zF=_DZX_=}aQBq_gdtTJ6d>@`_y@85B4WjPFJ5vBMBnIxVA_zLoe3gm>=C6QmW(!Ab zTlq9R%5y85V0p*P3&>wr9xT>x<|7hP!7~jH{ocm=-&b(`*ORT>ZU2N9{4cSBvBE#$ z1^*>h;3Vvk;#i~MqBraER1EE)pvIonSgQrhRb>+OCR)yH%~R2@m02Bwn!T7>ph2S~ zsCZ3kDY!h&dg1btu1`QwuRH+QC|5H7NN`yOy0WkGQe$rA&ugM{SD)U zTX^W_0ym8_{~oXZ|Iuu#z2J#DQv31xQmJiXJe+^&#!ZAIfMsefO_$Lri4OG7v*)Ub z=3b4Vom!xQ=1HyN$2#kz9=SyToBQrL+m>AikMhc)y{#=v-n#NTfZP7k^l`%V#&JSR zyy=&Kcfav*Re|(K-CCJlN)+FB&4Lz z2E9#%eWd zgDo*oatjHasKpXBHx2o@$B6U)axz10}zvSC$bEoSQi- zDU;{KLr7#_1WN9?hgLxHRXunpO2rup231oQ0*87ctZ( zWoBmRg@*gE_L-ce#^@^4!6}herx|d4KLGKm)3h|32&X?r{3Ft*r)dyRVW$z5Iw*5) z`b#hpmy)4|bQdBHAh}VgbFDv!`aNL0p9`X8{c=l+T0d=3HJgb0B$#cPlgbaSC0>)28X^gi-qJxU-< zAK?ywY|@X7-Q1f9!cRz?Ur3>5#~lXyi(5)=xi{gVsnk;3^HgtCp@M1|K%{HFgvdo` zco&&V%G6rCsSpi!!vUGu*_pG<)vypC-sW9+2Ac@`0Z`jqgT z{dfz(tYeVm)p_c#R1|7uO#9Smarpp%uIAiW8ahBYat}pZ-B0h;JV1#5El%)MyPwva z=o%TY%9fr9MdRaacaY>Uqv2yJf>}8kmWAPNMAS3cOjVvj4PY+)abr_T25CH-^APz2 zd5BGisQDZwpqVeKa1UWO;Cl28jb%iqW@V@OAidC5l6P*zQ^XI?0dtA$XTzwUhfo8U z-i$q2o!a7tCt(Q3qzghb=aM-iKOxa&h~Q34WIAUeysMj&-48#m#cb1TK0-scAwtu^ zv*)4jP$i^Vh}v67f>#rMc@(Ib0;w^%3#;J)z3};b3T}@6I)Hk?F` zaS2L?){>WBgx3(kEh%&Qbnp}?Tc>B4Q}7l}vlL(iJG2}E4xB!h0$UoQ_KG8{c$VjsS86q%!xZa&@ zZ6i53T+y7~4g7`pu0sS5<`S-Vb4&g^3cW%ieYC2!yB z@NYti0)Z@BYrWf3a7bhy1xxNB!HGmfyt854QnTeIL;%_djbY6{LX2S52;mt#5+O#w zxb_RFh*S+h)b7_7spud*1tFV1CaA+URoZ6%pks63~Aa=~m zuo?-@e=xjnJ)OIoEpvt zhbgO(<>cU(k&<>kK=o=WL;%(>mN>OG(liwc2{bYz^F=erN4NkGA0()++K`bqjG9hp zCwVz2Kwz(=>HXR@74|Qt@Tqew6yYX}%R|ZpqT5jUUo)IsC~GGL=mOa_yu6h;@j_$s zc?dOgEd^}i3#`*(y}y&6;I#}X>{_Vz@bwZB@$E`oqTaZNo95Vz_L8qdbsn|Jv*h6JH&yMB(!ni#wF+}pUyRetd3X!~{_wSDv+|)tO+_}}F>4kBh z#9KF0-G%FLHcrX`H%vE+2CalNW4sW+?&a#eMV`8kFsYo~36Z?~ua_fYv)q<4J7v1L zsagnr6|8v&DR4}61rkWkQkjXX5P2+Kl~~MxVgiuF(v`;zQ}O_)qn8SC6GD&2gIY6D zfD~mG6-T2||;}gRr^-+qit7(Gm`EW&vF!55I2C2|`oNU$dRdF}#HcXO`GS z@@yLqj7F2Oa6pm~_iHL#cTK>m17IU^W^<6QaIOg}?jm{Hg*Ih>>mvEvZEMQD?jp5l zy3j2Fb3g=DNhCmM=*~=CBtJVp59Z%h^0XW6$$E5^0v$^|69ixOCO|T^Q43*`ml@zp zvVWkk3`bMCN&y|5eG(wSX68)JNVS&TO-S-ZMtMp!7!S@)o#i7O@nyesm0IM|v9fdV zvBIH&u>!x26IXE3rUPBeIcZ6hK>8nBLZgJ5%qXE@3tXT5Vidocf{vomjt1TPZ9aNN z*CX$Q5n-?4Q9|U9C?PE^if)~wr3PFwPfHm@+O!g(E`noqLrTYaG`=mqgT2~KYT*4Mm~x?LF9qs2RsvbKP~bVGG(!V zCH9a!y}S_%Z4Z0^Y;{$N*V=xT+e7lm-9vF8t*$&sXGi3x8s{x&F$nn?KGJYW%gkZD z8qIT2=4hbxQknsm@&qZs0$(7seD6qzU>IfoEz})dd|JoV50$RKA+Q19g0jUe=sUO3 zgFe`Ats7)jr+=gFz9}+qp`B@5&Znv|#CwR*vR^d;$x&{X16W?Uj1BK8wepm-oK;$L z1{4QY)Kl`B;%klY22N@lj`Q=tuPXBpNKIh8Z35L=0yQEf@Vh-#$Mfp>6Ybs~!$qw^ zmNZr?WC?Q)lUfa(f(BJDdW8y$pwz$@3LvE$qftQyBvw$CdjSb1@atul0@+fiLZFa= zBCOU5N*+%bCiKFjb|IHJ{UxU@i!s+Z@JQL{17KAa0G}rTUljLDnB*=>lq`0e-(vT| zBwyVpOztK5jvjjJzDY^_={_j0M)??#+R**t$Dn)CWwOSVi%6gXv}PJs0xh{TAQek4 z7dcb)JjWLIl7c2nvDVzx8Qepl(W>kPLjIyUfvj`Y9Sj79@+Lq<3AG2q;GovmgVK>z z?Ab4|)kt@RH}=a_P1%PHD4jFRp|_OK*nOZm9T;Kk!Y1|x6UwAo2X+Yjl%b&EoI!?i z8-u88$p0)S!O}3osQ`fJz+PGX+kGg26|JwKd{iiN;M5%D$~e@oiZzX687kUWgvZqB z*Ogo9!w<0)>CtRlrS}dxa(QKiQ6G+4Z_PEfy8j8Im9_a#I^&>0!9zsu@cha{%hRyf zr^4p2#0Y7M*GWnW`XlbNGOOIvh)Nj3zKMX??8R*IU(p^&?G$y4os$8F>HQCNWYwi_NNEXL!5rz4&Lct+uw z!SpfGW*wAtW2Bb4KiH`lDX7V*yC{ruB^b4Py5KvM<}>CHE0y5tv3Fyo{?JTPVx|4M zg~m4qO5Jq2b?m!A(t3S9R(|OqQ%dc9RNzGR!eA6~GMgAD{XFSq1-ZoydG<*`E@vJ? zv*kO%a`0dx`8fpHM+Y_3v|G#-9RnXFsijt@5S=ENW>px1qX@7XrLrbI0hF>Ci)^Jayp676Qj#VbM&{7&e@t9NcRlf{P!jtP@ zHks_Zyb&*z>SnT02~t~Kf0maZ`8RF(^L+;tDOZ5t7 zn}$gRE|WZ=E;WktlW6{lYFKO08j_Pd8i|X_xdK8#NsLFP6PLT*}r- zta`XKt~p6x%E+fr$hdM^AeQW5q8BG-l|x-g>!~^|gv}ZOQai$mMo2B~&KcR>5mH|_ zS3)$OM1J@y(FU08NNKb)m^TRvkJ;3b(wi`++pR?AhZUt|G;r}^sdPBqUNDAf170H z??nY(V9Ezva?>zWcqjuX&GiH-DhR>9((79=9rg2T{W08T z#$DxB*@N1_oU~3^LzER$msiSjk}Z`6BUxp^HIs=oO_oA*g)A~zav#2fpkLqNxQ4uJ zTyd0NmVJ;z_XA2}Rw!i3m0*naX?KvqFy+7tTH1kN7s=79) zu1{3gFRH7-XpR{+nq!V0EybzPe|FsxeY83Hl!t2c#`4ipm=4D#>&8f3`w7?rQg+;? z=5Rqnl&mHO2!8pf4r8aY4Wt+lg9^EhEl%ag{l_L{BAY!{@{~YgTnJOPvNdC+=?Ub& z;Vs}p>MafiHI(omJ?}hLK_M2UpUkB&o#Cs^p|Y4Hp$q?o?Zo zdawo3$omQXzP$2=vF3THrGxHGqt_&9gN{bI6scun@c!^H{jx7XnnTzUYPa=d zX)Wrybh0!?=A#3&o0S>Avd^YSLB_}_((^ir2h8q4f!>)aozjgoW~WMhb-AVUQFS-2 z-Zy>s0}o+n>ATD^-m(KqF(sbSd2~j)8ZF z$97xnZ;0(?*ieXESw}L{SBTSLDQu-0mam47GNT?cfvm{i8SkY_fp)q%%q2rgYu;^< zP36CfVxw@Xlr;G~)p&$)Q-(BDhw4;jNzG9~(roZ#yt`yd!*#xW$|>m`Me#vyxWCm! zX@1GfMq9G2S(2xRObGC)$44KqZ?dF-#@`?2fmPo6HG7yPP3b&sQJnDA;y7Ug-uv*J z#&Z{s1Xvq9(Rfnuyo_f(o{x-%Inr-BT{K%XPxA3@TUIZ*BDcQzkBQ;CvfcBfm*dud zL1S2Skel-GYpXbtYk}Udfu;irdE^C%+*}?R1GgoeQ{-e5~M6Rj3-`{a&)i;)dH0KwZK-VgVfof*FX~l?zW)NIp zo)4e$$`L4CRTYe_k|7SdTs8klEoQ&9G==$*Gi@ALT*Y=QmICY^?`OvsOMbb6fug|; z2WV;>xjTdya6tjTbG;bT)%@$Z`L&{cMLsfU3MvQy_GUb>c#`l;#*>9-F`m`WxM8?` zH$ch{i23<)xXQ?N+Uz<_uESww=S_0%H@oV{^{&~~a5Y>T&8|Rltzxg|N^k01jp2FV z?l?lbaEbIS?xTobDrJE74=k0Ubb2prSJNEr1nLF%xH5T})Yne8nMLGD%~{4W>3zFj za+qg<)XODn7f6T8-CU|Z$|e;^MU7XyMSXvJse-wr@{;jMf#gs9%zK5@qerWf`=&t; zXWc=cuIh2o(QR{_a3x{Kg;rkpxEyomhp&`=n=n?6#b4r=wavm0kIr^fB3Qu+Y{vTT zBqEQwU=K^lFB`37ZqGhnA$hu1{f*OgEf_1O>&xut6&N@tv!;boNZ_1}h;}vptkKR! z07JFfOCgOGN-bOTC6Fo^LAtfiKWzWyW4rvrlU62QQ1SfP_Cl#$`0pR6Sy7TdvF78d z3cR93+5nFOh~9SomX@nhCa#n|Ms<9#QaX><`c=}W{jzot>0Yo1zLUrubHyy}4u?~j z^b=sU1t$Hj6lMbd|E&S)e$sl)q@ zu%D>o5_?i44Zw|^eP5AQpg0w;Kvv9RcVCg#=$5fXYow9T@Hw+aa)VU-^BO*Ug%or7 z;@x6myX<(e6oHrHTF!*qtd)A$VXiUZHE9x{U%V#G=s0m3rMh2D_45yDMAD8h?BR~< zN&(*GmH8-L)!*5hk+Q!rd!6*MU6V6gP=a*^l7`jRgAmIgNZd8{W>T#V7InIA0>O`D zFK&`L(iCQsRG?eWLN;TlT+U{0mYVf`7c^HCvon#OXHmz+{7E!}On`?WW~XxFCld{H zMI36yQf3*CY?d;K?z?RPBgN_JEvV>l$<=<*Hg|^X+Oppr>>L(gCOd})a2I^ zSI=Ypw@OEJpE9R6k=>=nes4=mND`}(19+L%yX~Q9w$?x_DUfw)!NFNk8p{WGAtw) zlA#C2^k3a8WjT?Go^q8r@00qq;JMj}EYKNcl4lKhVHh*Jey4o;`eRd-RI0G_eNx+A z7rp>x6@*~XLh1Sn2)-Z`p9Xgx)py{TWDVJeJYudJ+3=&5EsVZsVeuCU;1FbH@n6HKT%^%QT~;{=Hy5VDU2>dp z5PKB!ESFl?LE|I5TuKF3DJhp;@Z~FN>sF9>lbqHQs#EIHI-kaMIU=pr*|9HwuqsS@v!BLQYFMO=R&EQY#&d9aTvEa1ZI;3Mt6zb_P;)c)_q*T^7U=>@p~G zDfif~6_T&hI{H4v^v9$gZqx8hQ&&E)y!8@AypWAKCdJ{xuhBs-nXiGBJl*3Gc^_N^3cx5%EgIt_9@#L`b=o^g(?JuUS@ zGk$YgDr|rA8sbYOkY4c)>&q$kak+Ro!QZM^qIy+<1 zcOXT#a*lpowe%2!w!u|&V6$$V*Z$35%c@x@IKw**t+vl z7v$sEc?fA6*{$K-ArP;x%*bioF8h_YX zC>g}f+#B+Uu^tTl3H983!DAD^tjYIMRNOm&sN_kD@ulQ1AhsDg+S0(RTk**RCr!Ho zj~Rlpr_AP->79Vl0&Lg}O1%er^Lvb6>)D;}rB1D3+1vE8!ZXsGe-qH83Px4t7lnwmbF*yL=6_!C1TN(oDPdBbnhEB5;6>4=LE~)8BQ1 z*1rw;K@gDM4vRBBx-Olwb4IfgJL$vD{{%`6Hvah&$k;RbH?p+yb!z`1d{nBmSnd4g4aB2b?L0#9zKD_zr&0>mff+>ImVUPkB>h<5Dyfy*vWJvA&4Avr zQIxw0?8PdnnRuHQ0$XqF%_?bjbGqF(IeZb~GcSgE&dkxsAtd$1-MJMa zfNTs9Ek>Z&Rneg)C6XoFky_{twUk_)GA5Z)!uHu6DX7&CyjaO;vmTl2gKwO9@?F}6 z0OH7ZAv<j2}Dr{OZ?)TQ0Qn`)Z+pW;jTim8QlNi~de80ePD z%hpgi(_fcFnVD^zeiy6CmI~U$ZvHAYw>UFd<9k@*+4>U;y(dk#fUg?2-IJVjcDpLr zj%skTNyf|7QmhVxQj6cEx9y%p8jt;sgBAXqUtw&UJrKf;lOZpS=21m0wH3@}HJB`V zu=pCxgoD_D8mU6}8OysbCEyODQ}@x40*(F;q>c_wp->Q2&KZY4mbUA31KEQo(lDn; zf?YBWsgw3JaPx-)7lWyzSydk@80_{r$R86sp{{kyc+x>m&_T5Gb&~Ju>X_I-&V_4b z19^bkou(98yLG~^H-&y+yw*Tgbh>WF7>!Zb>4BEDyCSJZAK1DBIhCiw888 zYq2uush3B5in)!SWxw#I;p*-Xk#NIsQE_QnkvEMvocPCQs zP+A!qddjQqblBzamPcVSQtd5o!%StZ4_p_S;v=8cIkH2(sL~tky06^LZncql_@TyO zzrjxq)WJfVzueJo#3#l?e;LarciGwiIha;w4NX=qrL&188!?0i$gR5&4B|b(EGE{z zaJz3Rj6Xa8NPMu$BVV)N_ZDl`OipbR0USfaJw*|(7R4`c8g6LBai5LJgZ-_U9O!p` zpU%3lTm#)&YNYDs)JVUwUz*85X7=-hH4T(QQL5-bIjgl>M_?x3A=0NqSxQ)^$B;Gd zqy-Tim*W8jZpSVK%J)L-I85V70f9sZ)ynV9=v|}S=5H*H;ay&No!xIPhhu>1+(PaN z+Y9L}xqZtp#HPfAa=s6HNXa*?%eD{oD0m~RVVr3xzYP3@Ah`qW zE(OW019-3zop>q~+F_sV)joVwxF1ijs^%$a!5D*<; z>O%QrYON_!|H@gKp|0jFT9HR~A?@LUnzG!XAqP5=45G-)Cs+@6G~q7^mYe$SFgsQ9;PcfhHGg7fV*<%h z!6lv=GnU%Ww_4LC1_XDG+{ExI&)P?R_f7g`OA!pab(B<}wsM=;S`-(uX#EKC5dlf1 z&ONF6G~2<4QHQkiaJV7u!KkENOfgejAGDSILRFZWhjx^QgS;@c(ePD+$<` z6T%ikJ!mV__K`h&Vq;kUKFR=UFy_eis zzZ6RAG~P~jCX`7mrZ;b0J+w1H`u4BXc$-|-KT+&az zt$#0`lC4qt=qTB65OI1oJlJyP+nPpV^vN*&E6t z@5h3ZVtFZ6j+8UI%58F6cp5Qe1 za*at@&*}!tEuN2~?^)l~n4n3;kE;(KIZD%_8dz7ur_jftXRk_wu-1r0l{%%*;~I=$ z4$2}3qGQa!U;vewDg^VE$2IKgZ_WYj+g8?SlGa4>gL%ix7GdXG#7sos{*ZFllpT(f zgLBy=b8`88NMT99We{i8`w^8MnCDg=!y-osS7mB{`zg1Zsa|B3oc7^!=AcCdTQCDV zup4n{YEQ2dQE{kJQ%S+Hn->+(U1GLKFFdNr1r~voxBH_fanpdd7|9gPdNLTOW??67KFBC zxVST34$=e3Mv)KFK)mex3=os~c)3}w1CCG>tzS*WJCUR^UT*B<2Rrb(j|rZpq7>Sq z@Kwi8ISRowlx4Okd~DswQ3%daEJ@JNPrUnhORz9#>J{VxMQQV(25Hh~5x0DK5EUXQ z@3S2Va)c*}q(s&c`SF`G4S7?kw+&!V5+L>jGXJ5npU$539x8WetwY5qL8oeH^XqJK zX%xjW9tt314mwk53l>sh%UID+xpVgxz%5!&kfMTYg7*jDU_*{a?mbvn`#YhKqo{zU z`50UO7%I1GQqJK7QM0RHU1S*K$YeHu7&4R0)(?}r<1XNDhRMC%ASk|`T%zEm9DjtY zB$wPd&%6`mss?;`fDWBJT<-0{9oEr3gC!4_JG!f@o@bR95RjoDjq>pLceZi3obqe{ z>|KnIo4fFqv_^xCixF~Q;xmyy2gYTH*horjaRZNW%ciI)A-ROBQVG`J9SIS}5!dfT z${d_Xb{U}(H3DMQ2zGgd9H8e(Di@*Yg0i_JG3SvO#742;k#fv{eYdES6cvm^ctay1 z;e%eNVdc5ssEZO5y&?n<^oq<3Tu66YL6xhUKp)Id`VOj z`);99is-YbU^M;@hEdd&=uw9CVPd1W+Pn%Paj^X|mkXY1X%>oZak3 zvfQFm41E_?)WD9hg}2k9(#TN;e!=59oQ$%pJSlIoE~Dg@y`~^L*c_&a!!WK5$@xLG z1Z=D#-l8pgy^fGHo8@Jl1s}ffFiP&;m@kbhH7Xwx*_l!D3f@TWp;VB=w`(+}dG0DP z;2eD^Z~MS(G>|t^RynFs_3TU(at`XJ8ij-sR!_!OM7Ulyrzf1RzUno zWA~eo7!e2i{y8~FCQ9L44SI%7qvcM#j;mPj(ddfs(`akjH)_tEvshNV>^9QtEUNHc zxe8p6X|6A>A!Be4LO>g?`tVYXx(rcR@EWpFO48V0kiKL0M$10Uj)9(4%B9(29@JyB z9Q+I}rKGdqF>(|c8eHiJt}u6uysJ;hv>`$^o&e;cW!ezo>C7QQO@`_w7(MZTo4;+} z`E2}H$X}z_(y?+!h)a9MLLh-s##lMfHHL_5Ju&UlM5^G6tZuCA6MhM;YFK{+wQu3k zd>D9I^9bZi=!S1p<(F!XX^jAi-_OfFjS4upOpSoee_r+vd;J;APL%Y8qJl#}O4On= z@VJ#wj!GU#o}EN!pI8EM--A4(KSHd~uRjd`_Z-H_x`43zsQyH?QXQXNT>GB27%z8I zSJGCparoA)Gp-#kx79hVqs6ygtZahZ+G#R+i}DV;GePd!D47O7N4|6R_(v8p5u=JP z8#+-AAVt85s7~BMHc{?s_v9=)M$o^ppC`(#h}sqRA0Zv}3C5>@9I9Eub+cU%x$LB$1E zR9q+*G%Gb+aw)D$X&1$7;^S2`ad5|_vNE&Mypk4*dsgI@sTrl^Lr|HLVxsr=J~PkV z(7ylA>)$K9&zy7S%$YMYXU^=}z)LV{B5WbP+9xo<#YaGtto4Rf7`=mfl4Pw@Z4oG? zZe?e$f2`MNV`v^HdC#m&Vr^5){o7JfDS!Af@*e|86%I_8Bg z^jlRNnn)7;fQ?vQ;;lGxBO=wEcSxND6d&1=DMwGECzDS%+1^9uAgH>3Cu%9(&fE-nOxE7L3pJ?$psr!t7cAZm$>LEj zDD^A%o0Iw27nJa3q%OIKSkQKaKyPjBOqGHa-|#o{0-sa4zn@|-Yjggoxr>%7K9 zr7n3?dBVu*}L#5mT;Rg{^z#nWvjX?2ewOgixDsihBws zPLI0=$@^t2fuV%UoaIo(PJE^o(mywaQr1G0<=JFawZ+%TCnP{>xxi%!9C6Yn3mgGb zy$pz4ll}=Yj3mA00Gg*zkNX4sVtDun>w3ky@4_*dus7mw?pfZ2121klacq$ktMFHUvaC8|SqL z*7U<~A|GyPEy?Olc}Z#PG5tlp@+Bo?bWM?0qRtB-VY;HTF`Ehz))etc9i`?bJ}=`_ zU!~r9lgP+8%g)+U5UeF-UHF0e?Q;h_QfBb?y2El#9=L5s0&X~R%~;sB?i?hoG}e}?kZQ6gL+ zOK%Bsj*%;hE`@(TRf+O%A*rQaeuC>>P<)VwOj8mu1v+J#GCCDyt5qYH9 zzGJr18@RAnl+m6oo_FWBzhwS?@8jq$u`$th zk*B_@Y^M`QY0CTVZ}QL5lyKkQzmUlB{HHW@Z#cnVP(Hw(xV;8A^`7}DlD~gY2JzRY z@o%4@M6efbuCkJ3o~uN;|HIGD#a#3DvFqk3t=wzz$a%=f?|j5O;4IuUPg(5Vf&0u? z-o!)JS@V_69p8c}q-FTTh#)ij7{_v~9+>W42&kHPFhXwVoJpaO2y@7%BQnYfJ)Xb# znv&XVHtHa)rqSR}?*v3u4nXauPCy{ELHy2Z%5==WKKHuP6&l;{y0QhkD!MGdOgDsB zpbT-}&VO0}0V8>>h3L$y^L7iBuFcL}C=+ulmATJBwQz9X%~vl(ksad)7h;HWlmCF9 zhF;5YKHjrU`zR{vqD)wM{D)6@b(5MO!Rx)DG-%#OlEnzJa0DumO_cZ!Jp2tMsOJ(H z>L{ouJW0J%;yXq8V7@b7Pn3SejZ3YJ@8C5Y?XY z;D!L%L3&G2XV*vK+el(@+OkhlQu^a zwOMOdD4SnI(Ai{-y(C@t%DMq*^$_Z=oHU!m>BuXw+H ziPEHNJ9ufd^`trd+U0v;btU;)?6u4H8=^zLPxT#F$ifLC{y%6PhT8GK+d}$iqjz>k3E|>;MJBXEjn&Shh#5{IYO8sZ5e>}Me400pwE)5L7<>`I-jykIpn_a zK+{ZRsJr_hK4&@BQcm)Jmn&gdN~xz}4dQj)S5>;u_A^zv&Zx<0*(XI6;XRitLDju1 zV#ZAzVQkM=tx(>tB8c*M53^EVesAE<*}q@oM*H^|zSXRR`Fp+tG3^iSQPb3#^Y6^) zAqQf^vhotGq_0$3`2P)cRH6&yH&!am-S>003L~DmeBdgqPF&ydT!zxL;TfW1tIToflT|iF>9cfUrqA>3O`DX7(z~cw7|~Gf4pV zYRCBeHCXw-$kUG~0kp?)jS|qPG#4v7SVDK~s=WdTcGboXuE4oVC|Zzv?9b)-YZU*$ ztvbDVp1X)LpNeQX@AQ_^1e{5Tm?6XfuNvw?&>>3_qZ7bpFNn1SA| zF{Svo`FC$Ab*f+63a*1IGFg@_x2^IB`?M7+^ZR zU~tdqbI1^?$vCEN45w;x74IkYCbe2O@&XR`UNUgs%WLJpaLG{Uyp7HklsrgnGmI#@ z3epdyNc#bDkdwbRNLeTG%Q+Yr7nX-E^HU&i4d zOUgigbc521YWYTN=Ge%aZp893SZ;(2I2o}KOBQ&lawGf!j5IbX10Yz$Cgl1ekJ^l~ z9M2`+qucR<1a{~@q&k3IC!3TJFlA>qq2*j$w;4kRNgwvwI!S+h8_{bPOnJGrN~pks z7vhcM6E`baAf;;J`&qUmZOQ9wQ5p^><<$_CaTsZBAz}SjtKS~^*~9FAX1GlGB|yjE zVWr*~4}A=W`dLxC_eEc|EI?M}p1X|BF#T^LQCs!$ZK5Z$p6}eEw28DePMTYAH08@{ zg)Hj#dW#d;EZ~o~C~+}@x26V&;vMXxX42GyL(rEfDg+%|;g~AIY2&R*(BQ5>jZtG3 z|7YBKPl@X-V9RM7%1)d8mm}wND&kLmek(SbT;%QcD*;0`y(JQz_KhMa$~{4`46rfk z$i;ZhQi!_HNBvUNL@R2du)&il7F(q*ES+Xm%3=t87(Ok?O%Ienk?=?ad+N6*1 zdx|Rep#P(CLr1yFH0*(&x=m?azXip`*)e7jd+{(U=N)S(d&679w#;oxpvQyN{PZ>@ zxbwBupi3@CLDH(Sgj_z1+%eU)V{3qx~_?3*g4ZM_yRDsW537C@}Mi!F`c@VoCSBYa;2 zk~-)=`OsbHz*-#0*`@UJbRWlyK0pWd>6;>lS~DKF8*4N$x?iC0>a`mk3>@g)*m+ou zAJ~nmc=N!IyOr9WD4g3Lp%?i)L&j^%YwX2(mxQ`!@a}t+KrwM!MfN?<^9g&=*WpF0 z&a7@Vj1V&(lF`J0=DkX2kT-EbwF?kOcxz{l%<(VjMcSuM5RZTq?}amXko$bBOa=?; zmVM(E%Y^rG^T#j{dS{KTloTrE7e7`S)H=HeG`P@$Es~ZNz3?YWif|Ce`KV)koLq%L z)amsldZtdh4C}mpn0hJWUy`vMpm6S1tDz8R(};Hjyd0J$SI$>I~hMpKRbKjN*dD?5{;9zAqiLCT~8tAF2!R54(f2G6WNtiAzHoR!HoOL+HF{K2P6X3C5np3a@@Al#5y_eDKzSeUA1as{d&0{u$?pTL6V^o|car zSCB{Qo(H~8F#pw=DT^a|TL+gJzQiIoo(02n9oC9P&Q@=cIU84DA6{;P!a$`HEC2zH zO7KE>v9>#M1*5#77}Roia_)neKmvtOy#P8fnGh}KCWOtwrrhpLl> z*WhH`M6d9f(y+}~!Y4D;f3XA)qHtP zYXJ#Oy^`!Kpv#PZ$ql?D5Lwzle)ltdKxwF{ekNkygRe4#N@W=lv6ZT!;>d3vX7=|m zoJz=eK+$IaGae|%SSLl$Vytu9@Qhw@pJdqSKNtpiYoR(v^DH?UnoR=u@Ph}iP3`G< zJNnxMeR8X0N@@!=sCE@ufdcb`}NVs-`z8v$Cma5+Npd?L|-J=)Hy!aPVz8 zetIguw*SR1P#}n%(~!!Y=UXt{fmc=!DnX$iz9zDzHNlk*TbiQz;c(36cbYI-`JaO$39$ z!}dfx{N~8a+&9Qnrmc0(jK_xt{@3S9U5~W}nU0ajTyitsAaj!djB7&hxW8~DRFNhV zx|t>u8ugY-LL1UVLhg%r{FjP9n@&_N=?qGf>9hyNH685z{SqU8skQL)uM+>oT0e|Q z(9ig-Xpc#8^fg-aJ=xm`?{|x&QZG3>w3z~!qdi*9d*&-+z>(%!Jp5kee;-l&!ymjN z`s4MEG2ksg&_QS7n6!PW<=88ddXF=;IPknlP%p}aV_>JAFR2^9s8gF?bDEeLA|f2j z9E`i+P$h*htz?A209yp-nH(%A9uYo?m?OfO4~QTB`RvMKzXyoAuq-o9boX*XX{jWh za7*#7&y$#4bYD1kfCJP#s*F>1U7OQ8G(tCGg@bDU8bm6zXz; z@*EcMo-a_se0zd~>id4atUzf`M@kEn27$lLgpZ?!sOEVdqWQm0wi-DsP#Q(=0ZzC@ zKB}?&$Sn_Z$iorBUg+}{D@9zUI(iOl1wW>=jZUP9)K$SemD_qNe3!`%t2NM$v4)uQ z8qVK6rVRBsGlLhMMBDs$hLp7l4?3<4Y&)KUV~Xpz5>oF3p}_W(&UJ8^>=F0yIw!Che(B3Xn1GiB2Mi3H zIKZNuP#V-$$AbO^4t?*z*BlcsaNOo>7sB}3q6TfyRmcrq!Jdq90)Oi zAhgRKpi|aGz)|*-ia*`-a1zsNXz?fEY~#evN%-$L1$+`2J3Wmu<|-Cum`^D^u_{g! zzGEZ>4o1&Bg?M2CTH9Mf9o7-^a;KEm9w(;qRVQJMA=_!CQ$Q5CB$)Fs`Ybwm0i6S_ ziRAH#r}6w;TGeTtqsCNyokLuhS*F!M9BV>(Nee9G zt91v7(h{!WuTwy{d}MvAcAk1F-1UaFrCt2*(@Op5{dU|Afh#54JS5i}$)?I=>$xP0 zfyx=B-nha`@coj-A?PnYN5VL6q5)(zl%7*v@B_XL#Y_BrE72D|m z4I;k9yMG0XjeB9fQo05n$E8qkBjF0*a%zL|W!H{3aJB5KRGvT;6#qDb_q?Li;p}T=Q;T+2Y=afbetqh6 zFfoM~+8TKJIQxJdAt1rz@^@b=_2TzHi5Uya-O~K*n4gd*!vUFgFyh#2P3H%f~ZYXm`sHeBG6&_d;fx8j(F*vhM3rpjEww|=8EX1Mg8Q1@> z{P=ej@k-^rZ{MI#C@9{=TNf%X`%S*?&^cBK`Fn**;r@bdaZ==jc7?hJRJ8tO#obYDiC`@e;8un2uopfRc^9X61Bp*wE{_ManV^_M zEHG-6?B~(G{Nm5aG=Rk+Vu3|xV(}NcR>7i<&f?&AN>~*^;l_XbP6W(gMQ3AS9X17chd$TLuF3SXvk^Q5vmg6AaYa>r&w;lTxh} zDNU@!3Sm&JX}C|iG%uHe>nI4FmFDfH;F}2gnYxNPf;4I)x{1yU*rUJ1=Uh;_CsDH6 zN7O-Ky<21~kQkwf>3pkFFbc9}&Z6~NNplBM8LG=dxUH4Z##m|=w{eAv*F|(iJ$d9s zY<=_QXD=#|olcFzM){Ee71{wxC%aH&P17>bEn5?=4K);|lE`F!=@<8p(MAfb5pR15 zYb^)(j7v()K#QQboq8F+X45g!n4nrmeS0>AQ9ECzeW4|>Bv_?!Wcopyay^@DzD)-B%9Yr^x#Vx$Y zWhF4Cl)e`urv_h~D|i{5Q%MgTD#~@ zIwE30aZP^wveKgo#-S&W~x4G>+g$K_7-xXu`TYiVSoG_Oc+!&ulJ z?HlL}0#KG5N?7XsI-YoA(H12#sKClLel)UvKv@W?3k5Ss-Fbd}s4 zRHkyx8(pBij0QtuyN&%Ey;?zWHjlrebZY5K5fITGzhrB@ZrPM2vL6MVSb_l4V)(Wz zN^mbP5>ei@&ZIGa2JA|z<9l!grE7)i?dd9rX;1gjWJ>pY{`iX0%y+D)LdmIzc$=$A zW8+)>5$h^0GD5Y{0{deBX6v3{TT6$qp@0Mf(pv|d90Wi$05D%>i*|PaVE5vkk}nX+ zS7;4I$_*xfBi;H(_XditYSA%llA)XPdEr&X+xP(rgmf@av*`f2H;Y}(+TDIQZAG(T zdiYb4XgLzo!}m#`*AS+I1H@IEMB=16i!%&-g|9M+6tVg_CvoW7{3;`!dG-qomd0FD z=D5T1T~jh~Mbp?HF^`Lp^Ic4Kw0Q>nF+ki-y*+J{_gk?WBK3{7(zu^Uj1Q6p$+Yij zrfgf#CEQ5bJHjv%HJ{9-TF0{NcNAvZw?zw*un}ICO$4m(0`#%$BcQhnkXgmH5T*KYvn27-Rpi7qFgw03(@`0N1|Q zjx@}JE3jJ_b2pg%B$Srojy*p*F`7gwQSK)0qK9m$qi`^G31MC%9u8Oz!6p-|WCEZ@ zDvE8y7PoWJnFFWWz<(VM9r-VoY+{_)==5}`z?pu(PA`)1B6@q{>xERQx@||jFDTB1 z2@?k@{Fvs)oNPLH?f(lLc4PIy`dy z{aE!j#UKo}=yv@@>C}WK$~s%0Wtge66oIey$u@@qlv;&_7_O7nV2Wnfge6^x4MUNT*sl=Orf7<%rC80sJl2cg?PAe>Z*a7#D~3i)M-lskkdqAF43gQDIZ zog#)P9&LuG(f8EeLAa*1)vrpk&>WKCIDz#HtG%0R7s>1wqJ7Q$6{qBP^Ig9xq4h+z zhC5Tfl>^0FZu0BDDs}4#85_Bva|s>7Yy76vZ6%Vwv&ktPw39@V=|>k}xh0h+{e}`- z!YBQvv>2L8B$<^+4iPZT1z2XeOu*-yfg@5ZWds~3fW1fUV3+uhzbVb9I8}rE3g?;I z?TJ#IUiT2~?~M*=QG}?(Po3?Zp~nfLIEP*1aGH(v?W$8m@>RERs`*p_i1~)(RGU%4-RqpRf zaHuyr6SDmC(b;0h;}}_#!j9-9VPB&QrK;z$1P96(`h0Lv`Lc-bFH^XCc)_i(L)3o?I=V7CaC(T(iCo8Jm|I2HN< zGwqKTv812xxAG4NtlN8W0M4m@7?L0>!cqSEpGxpB@OZKh2_Txd#dKbJ0XA@8lEv2B zROVLFM{pApRbs&$hwcAVo{biA{_qy$l$RO?8EgZtj5Ai5i_ZzG7c_EK$Y=khq>-b7 zj%3|!#T%d0=|^nuEvu!y)5ku#<|KABF23!RiQC?qU*f%PTeeK6Bu6G8B#zNyeMk#MD}rSQD--(ss5iPe#I zS=%>74ZyxAu_SXE3wUA!S6DBIN(;%6NX5(sV55>+z1<~#@NcDAR1us_HDvi9HQp;D z-^1^t%iBm6{hbTX%e_rk7gkd{h{gDhPMN@UZg(7+NaC{*>V}AmenGjX&-WgfaprL^ zOZj7noSNmxjv64i%Lg_rURIz75SnfezIsP#LpKJgJ%p;rG34ZU!aOMODX~-Abk%Rg zyQo9Gqwm>Bn!F%Mrd?7nFN`}OAwz6Zgkg#r5Q0y+Y~P({+*KMSJRzQsTcVrx{3>Vh zD3bpEhsB@Jy$IcRke?|9!)6lm_q*8XDC+}lUdT*1MV14SidCz$W3L+B=<|a zq)e$71CC?VGwbg^z}5C8ZPbKQs@wh6WLvNnPYd$6;QN&7v&{{3M3h{HPu}?-AG)DI^8 z21n-?XNZZKGIx4h>$W@YvqkL`o)2bvOpyJ?!r&$HLJB9{xb_uRh%y1#lx%uOB@h zh%Fyf<9&tVuZc=PP3lK}^MMleA~Xog(;Bu_Xv5a)x$eJN+C|hU+_?mDhbCtVa8`d5 z5;P(DSJI*zw73 z4dtE-%j|Uoi#m_6-TxvNW*5&PJW^UWnph1r?CuhKqd}KgW|>96>jb3s-uJPvbEtNq z-GkJCGDu+dU*j^yJEkDQnLQQQj;L4k7Cx(doByTk=NMM(vyCh$p+&S{ zjYHQE5{qY^0se^Oc~12&v{X<66Bj!raNgoy9k3*4*dq4TN(*i9GM^5n8!_pey|`4A5&;31FfWhVIw+Jx>;96pTEbi0>u*6^>gH zK#n4{NF~1k87IT+P0lE{8m8*r54lACl)K}EcDO`B?H{|sgo-!2!bDNj%yb2&@Eu+( z5~JlpFBXQH{g)R+jpMbv5lZCk=qH5_#m}(ml=S-xU6K}svd$GI3T3e?OccrtS6Dv( z!W$`1=OvU#Iy?5$QKB>-UV20xp`o16*iWx&Lq3g z;VE{(x;M8%bieji3zJ1-4?BYQ@?ovrhw)iHY)UKYO0c7yoHuc_#coc&X^E!hzuK`! z2j_%+nTnLNd|41(bLPw5c2DI)tFgKPsdXXi$Mc*raNe?nzg~?sMoza@W8r9*`PEpX z`h`T;!HIA=w!fWQe%?~VD?r`iHsQ4ve*?0p9xi z3vbd*_Fk9xOvY#zC=?Xtp{?cbF-Ds{DOdv?3E9w?EVZu}9TsM+iSK(&rCki=;ni6O zdcCYV8$kA64YH14a`D5G5&{_(&2f?|zzeBbW)Xat0dQgOY0~G9>a4muHsFC-ZHDmx z4M2p~)6Yw*=*@f8U`>5THIZqa<+E#`Hniby)nF0szT8p+m0~>q9yEZnU^Oh`LwHAvIqs2|UT`lI{YIi7-KR??^(>Tj$ zA>bD-KpGd$ti@gnL;@K3sHaf$;)|R^8uA3NMj>8V(dW=xI|NwSkmQ2D?sJKEtIc8) z{h5V#hQ-IDqx=jR_+SEXIC?>;OiGe7*=^L6N_Q3aC(& z7`XmGfRMdTxlKTBd)jjgZ!3_s37XIta(^@3ksq1cH2!=bi>SAZuxp&KdTw{}ErG0Y zqkV*a#u1MDtLHZ=!EfZby->T&^B^D zXlIi|`z?m$m~h72VV~%$wm0w|1kVi23%xTL z>RxG1>vsCZ#*;(<%VYR0DDK3!)MGKhdm?29+BCIgz$WxW{zpC5AS4Zf+8bpDP|@7e zN6m=EhrD@x)+V^6&SF^e$}Ecb?E0*8U@8#Wj8sQ~k>fd!e_5Y3i(f{#C?_1&{|-_F zSQhPv7ElVtDCadl7mCt@^K^;>ylF6N>q}fHf{~98WUsPF`dPt`2eYQA^rZ;(9VAk_kVK2ngQg+n!cm&%OG4^$ZG4cE8b%R+ylqDB zB4`%aRno}{{1y~1=YvAn5chBSh7cCkXjFB|fRA?w3QjwKfOf)q*Le-%CchHGnuS!f zfEEJr?5@rApf->dgjn#4Lql2fPM$u9+}9BqdpnjVKh#pFBY`#}TY|w?P7J6`Jha5~ z1);2d^hm-knk3m<(}}OWNG~C2+AkCsA+u2fzXipNpAKc4q?r%)jybAZw@^O}dn>SJ zwWJ?r`3NY+(YWp_jL~*p5u)pr86E7RP(V+ANEo+RJ*n+zfRRqTKW*TCcWnbEU(E9` zQ1j+AOARr})MCu1pJc|-9;8`(rbq5B;Bc8~bD&I~%d-t{Ll9gH*09Z!8sD&f7L;t!w5k z#{?LMwGu}we3JOjW+gbF(BeN0v@6HR%9%utcqHG{oHYpSLx{AoIs%stVR&sB#lLIL zTA{mogdbx%kyLe%(5-ovwFJClV`!U~Er!*@#NsYO9v-bT&C5s7a+Y96Y!UJ<6YM6z zKD5Jb6Rd(@>+LX~>8St)O$X3q2R290(wShh?Xdm?8%eNncGv`h%_7(UJ1m`GSp@4~ zhvgD%FZXN70>+A4FV%D}%=u_%n>>K0mXA#kmVAm)X3LT}`w)P*;|VSj-X0Q{r*0L* z1h*6t@ks}(+60>qceVuxXZD54dM8e~Ix z(>$Lf+Gi&s2T8(m?J)8_By5uo!-f`oX;D146$_2FqjT(0$fc7}*4kk--WM?MkW2h_ zE0$PuZ2;A{O!0{9N$>beJTa0*v?`-4zx#|{zxDc$af_i5-ChX(SE zk*sNyAA-0C5|})HB30^P*GO10Zajmsw2NXjJ)6F9g(O9v%kM<8j$Ps_Mcauk!_U;B zIcB6xg~TkJn5_gfEl`I<5@Z2?zBOxH>n0gWnQCVO_vhKI(f{rPSWl;xgF>*X&I^fR zzJuZtEU3;yus+9?HY_qY3KSWKNmg7}{tIr=I$;`00m||4Hn4pud{G-%(ICF94GZXa z6e2Dc6w6FQKxa0^<6q5FFptEi8W0BwW0QRR)|&bu9DVgma4K!Xn%C)1q8p(J8A+|H zy~3NdWi1Q8 zi1(zxP71u#h(C`!r=Lk~hG)l>?>`>WX+ejFp{zjZ@KZb59i@du$83@F;X&F`zO_9It0D@a5ie*DiQ{-N{RDEqXx7&KH{K(fHF7WD zFVIgeH_^{RzAKuIFjkF6j`8Q+Gtq5s-$b{u`27oi{dy(3eTKi2eG=V%#$Q-(xNP|Q z1b;sP&hYyK{;B}i9e>mCw-bLiz^i&fqT4|IZwh`*__N{$$U9mM3(9oR(q-Pn^z0Sw}5XI8!HGOSJNkotaD zB$8Um>=k1tYt<2|)A_`AV%~g4M^+;!A04%wwxo(xSj=r@7x~(bETJw8BTb&Kab3s8 z`GJnCvlFj6c-?hmCuVG8qc1|<9A)|aL->xif`UlJvvns7;&-yAaoHu#D|~2Y4CowL z?AR`udIrq^qh=SlcpXjHKYce#A^*EGYieijx+CK)-lhwijWvSYF04Z>zu)ho-3w=T z?Jc-8xVE$ls>?tg*p)>EZZ5uS+kSNlGHT=g21yJb*Ol!6iF+&ylvVB&4@HA;$Gsr2 zsB(BQjefAK6$`!N8t7Qou1W+|{Cd17merRH=RsZ3aH>os#1A|?j@7TSguV~*c>3N+ z-|P7V`aVYA^Lct4YvK`npZ`7-^B>dri8$7>9=Q+8$bwz1Mvj}Yj&6BRao=vNdFWa~ zy#r6&&r}l%TW-36wpK0SZd%>syq$bVH(1hAzOWmsTlE-G##ZA;y0cIZpL@KhJF8p2 z&Tn_EB}ur~8#YfhQ;#Q|8r=R<(v3A1*SnsnLdB9QI+t=#Xh(h}or=%lH=wX_*YDzP zO-k7Pgy~!Q(Pdl$L#5mPLP|ZoD#`il6LJElnnn`q&z7SLET*lF=-Vbf;O6cuAnXL# zWE>{p(5UvnjmG9u1S}#)0X)Auv;{A(I}57+$4!}^l*;)z%WL&ujhjN7+D>oE&nQQJ zHX@RqpU7X3pH6&C4>)u;_|hJ%LE8e4GAo2h1iiMyOkH+1ed}3#8(2MyMU+KfexV0+ zKAC&Qqp6qjsCX9GG!y1bCkmMXA`>L=GtEI$$>>H)QdR>>s~vwio<+Hz;alU;@4e5z zjAx;>Rybk`_P6;T@nAoghxBAI=p2XjgoNd8Lc&Or@Uki-q;FlqE5JHS*qv|f2^Jgq zH$Bk`Q~8~qEY(kl_1+4^Et#yFmAX8=7aP&*5e5Q!^kpRb17z4R4GM{%VtAi{^dDe&~IVGR2kL0SJxb)O6IfX9E-*~mwM*2ls6nB|ldGgx(jur%`}R60@<5^I>o2mz z(pNi1l9%v1NU_!kM~b41F+0(h#Wb4ZpcWS76_lD`So&dV#BK)vqqm9apsCBeuC@n(`wKvP??6#mv#_Mrz3(-^x`LuqRD0b@cB16DS_HeeIPBjrs zjSte&U^)B8itcYg5Osi;`>_T-34juiTl=wzRmw%@{6W?9=#{Mjd?hlgY z*NU6f`?GYtTc|2Lk=fonEEcl@IOR0}RiF;vLqE6$cmNzLTzx)(MM#gT$k)lE%J+5h zsB(RsJgRhGCy#1^ukfgbh`u4-S9nw<*r+V}vivL1WWjf&$r5Pt8fmf&qxF(TW|Qd2 zwi3a1A~4m(+=`8+kh>3JjXXAMqK_H#2THA^>IvaeW0kqARQ-?V+jBl0RR|rA zqL=h&B;#xll2L$urbE<34j-aYAY)d@HxCkX^7{v|L3DJSMn&+2lH}60C6dOi-ks2N z9YZ>~cL@h3G7gJTmZ927Z|eUks-E_n|Jc(OMkM0_rF|IQud@+BQR>~v=L?WRF*hc% zI?lC)f0W3SDz@$;QFb4RtiHG<|0n)9k=6Bw%-GBj2^$R~Mho1!Sq$cdqnTILEVv7H z|I3oZdg7H1)PxcI$Y4}~OZ?}-EC4_E2g6LuP$%#hqh48m|KTXD2ybiS@iRbZRxO>F z!5O>%{tA4=3b@~@_Q>{0eDirjScA9+l=DK_X5^WGH_PwZdd0NXs%%W>iAr>iPP4YS zFlh+u;>V~~e}%#`go&57f`_uvQM4b$7lU?cDUwB3$e=gP9(QQ^$6hJSUdJ({dV47A zP5TChvIbq7-*>7$dJ*k|3#C^NVL|soBtKI%xWdjw#Cs*N2wlgk|5qK4Zb;&~VKx*x zTLx8W%Aew~b1dqK@_@2*z4sqx*ZUwRy|3Ewzw2GEvrewYgMavuL^w|;@IG83t0!tp z0k1!twT>GARk;?=_hnBOPh+C0Ts&|ihuexL_%4d4p(viOhO=(cXFFLYlU-XRk_{mr zW;L{I&c23|R(i3;{ECOd(AVaUK)vhF=Z_F00t$^#ijb<;;!mn*<0|krdZ-@b*zL+9 z4@c^{pJlI6TZpQ%$hiMyBy6Llp1$@B2lA|B=3m91y5DI2eli<{t2RBKVJ&fNtj#m%&qI0QGibt- z_;d>S@#XmGb)*CmJI%i|`RlGVt${veB6!syNcD`vG_B(1XTn;jON26B{0y5CFGx*) zqDd?{2aB10_$wk$^Udf+Gf-}65$T7|xI${DA3iN0ff?OuUgB$>WgQYhnl{KrSz9!R zO=u42_^4?ec)woUfQ zT)YH%vD?OX^olbMXy4W^ei2jbP0{O! z`JkIfffmJjg3!L);{jg)&zC_tdHv8Pv@(n-%_a+6cDbB*Q-qJ%!^R5&(3yAzOr()B zb$e!0oB;G8z)=AZQ-m3USj?%;6Q83fm(?ku6_PQ++BoqkrbN*j!S5Gg;a2q$pEQMq z6Gp^*#3bU5?6#1RAQ%>OTLW_ntpO*=1gUV_Vuc(r0W?{Zmc~)-Sv(&(}5dGi?Eh?PQ@`9h#1es5rKqgA_FdLtw)o^WdB2XWS`aaR4Xb zCJyCmXKDJA7L7}__X>@VP?Wfz&c}NmwW{ag+uH)7>?P~kI_urU`s1I$x*DiXq;tdp z`|`X~gvfCq))9g>{8obnwbzlQprRF1aq55ZkEFARl$Dgxg(;lW{%5Mf5^n0g>tbi3u!_CZ5e)P(e3NmHg%g5_C=r0 z>jPF=j{+*{oe0vU;95HbPbTam)RL=)>L(NEty{OrClhXxN_XN!@V+EEsGb^*T0|ds zV#82jOuY%-c%s3akSnY7uhao1s@R5LLav@Wh&r1lQbV1_tVEo41m;x zT}j#(_^_+v0{DTM7J7}u)9+l4L7mG%kMFcHS97D5tt?HLlHq9wiBCgZB<8386t^lsC!xJ6wc!FOm5%m1vWTsS|K#&h~$nOM6C&+6$B={vj z3hA2a0Xihn4hhmB3kecLG`D`2oc9o97C}DKAwLmhFF{Pd^S@tWO^rLDOc->^+P`P0 zqzGV1fuglAXcwcrSIybE4x)>Khya!}B6@(92cjY7>`e}$y@H4UmSseAK@znvXXiMG zR3hppAeJ1W`bbiFMdz1z>~&veqGL1Zhv{Fpv?k{4wT`I61b+fpc2P{jkNn3}7Fl~1 zXm!<>n~}+}#XNWl>r^F|bQ#Kvrn2x_`y4d+1TN*Zrm=AT-V}`gI^%@`ygMfVR|qhV z0LvvnnF@e~0HY-!jsR{{^vxyUWdN$i6X5egdiCiq(d9>T5Dm`|+` zusi8Z6N>a7Jg9Xqvj`*Rj)H*5T$}}o(DP4k0kKfTFS)a1O05F7>IM@KcETs@U;t47AN1=fBbVKlI`+wAbSP+-JTQs66?x_ByWYf1Zwv5ICa!W+p?<5x}6 zsM$gZwP^?y|5U=C(P2@-2}szvST4^02cDW9C6aPtmvs+ydAKd#NL`y6kWcmb{0-s2 z(L#12N=0v{eoMXwiA^`bryaVXx3nC(83&Hex)E4=dep^|h&#T4ZmO9`H={7MvCSwm z?n+!o5@Reo=_k8xTuE*p75r?v$vEoatR7d|W0F>DjOS1N6bL<)5CFx6(UC)!?Ot3l$pRnU#>>Su6dA z;S*-#xu|4NVYXqU{29R;zQXF%6AWdu7S=>NxZyFy8TH?B{HaFhra;D-y5TV&JDb&e zY7$10)P+14Nt`eZ2N*_~8kJBDUEl-Ncp-e!luAhamws4~`I%^RyL|IHfOVr5?Q)tR(&aCB4P+G$dHyRb!1&^9Y<@EnIga{lNJk5xV`xtr zuO1jFiUvx?Pg5tmT~C#Ix#S2-aqY@KuvoeZ zn?QwDp>N|;qm8r)A}s50g`sS@lHeGdKDm3-Q5 z;tUsrX@XEN9Ec}Dh=bop)P)INK8QFYiDq8~-BZQ;?6540`loqT8VgK*Z5xc{qf;oD zQ=`Uc$6&VfXs#`Gri><=kwd+s2yCYO4S;^_mWMw~WA%)}2{?Hato06W7Zr{DV1zH? z!l>)X37p+P{BcM~`H832;|Ii-9WXX(AKp!>ER=D~c7Ebk#e*WwB4Mj32C4_#l=~l& zbcnh4zhkC5V(LYtUVf_bo|R%{n#x205@*qT24S>ew?`8JrAEhV&tZX8^@hmX&S4=n zs3JRzIDa0nChY*DZm~Ij@iZd-6)cCyc1#W7q$!ebn8SiYQh~hxA(42RBJpo*Z!bUd zJtT$RfPXg!EixWZR3s8l`|JcXXC`UiV#K}7^IAwnx_Hy!j1K-!O(nutC( zJV~6@R^8Uej*Rd!c*c4~j2V>{!#B-kK}OX?%-u~f#Lq;!AO=>U4Z0or7FwrOWL6pl zKT`o98Hb6|&Cp%vY|HW|$7wddx0kKBPr=BL0z8EUkhvYDt$;&WEPYucr3>oj_)$;U z^JqOt8S3o7*|PN;5J)WUNz7Sb#%NbCXK%`%@2wq{grXoq|63~RqHSW`e~oH7m4qx~ zq(ixsM+R;E=q^AUp4KRm6Q0kZWB*IO*C7F06Q!EyXNn4go8@W_D}bJLu2h;6c962uF~7VVbzm61e|p zkKI6s{AZeOi}rY%`@P13#XZxNQnVgGO+1~+=otW#$2Gm5ZP?-mH1xN3rYjqx5jwkG z2x5Pi!(uDy2(s_fAt6j}`+;P7mlz=nRYKVHH1R3$1N}Z4;iW1dV}eYggy7mYu#qTj z%7k_l-=oK9>MPXcd=AFgu|k(^>VmtLe+vjM@{gxctv11ol)S5C8wLo;{yzju6I8lj z#8K-g1ry&brC@hwJ1P-_cz&io&>*GoG{qR+-$*wEAArbqiyvjyib?Xh%~!vLF6w++u55cU^{AF6iw*iwdTijG{7t41Vy&cNl(W7q#Ri>A5wS9DV0L@9~Cn)Xx`y9zHQw&vf z3fFm{bhwSIzDG#Ps?(Ec3NX4R)caoXK498LTdzJ<57X9g7&v4gF}zkVj1%yBgP z*HIj{v2lront?E0=6xV_D7`gOaJW&x8J&`^C6k9A^&-aax`-may(s?tL>6sjMY~d+ z(y44ZAms`@>pXXnOp>P&w@7c0fIhAi;hIZ?u`UrNPy}PTjDdwo zkfImd?l4ZSN^F40fl6GEGH@kB41s4iixr2dV;$F`T&9s4)68jPth`E|{~);F`@#MA9UHc9Xzz zxJ+y&0+uAxe=3(u!G);IX5xhnEyQJu;G$b|+5TNSrMwTN>cS4fgy_n3rO44KDqyeS z#vM;Ml z2Ev{LF$kv*ENYyc{txX8p&TYn^^~J@>A~q44Q`E$N=MaRWvD_ps?1fVp&LW~{7kX< zH(C3xC1ToKg?t)dI(&uS-xt0@vR2#?M9ErTY!Mu7H?TpdRk|Wwy|qsfjr6GdAL6ux zeHv$-S|d9btTLCRYSY_rE6yR+Ifx3&ot~NbZs_GKziD_&7|>c z`o^Yqh@?egT$*us9zHv|rA22PCZL<4C7GralF&@3ynI@VoFk@F2>P+R9{;U98!0V2EqO^oZgK=UO(NqW0N| z`W*FgrYga1BZsfzMCId5bzD+;ixjzWIcC#D8e3grtJyIS!{HhYc-Psp5HCZ|s1(6< zEhES!f>;~tRw;tb8JQv-z+3M)Cm|L~n2e#fIoF|@1>|IpW+5Sc1|hAXPU+;O!%JJK zQ}%tAFHl*C?C@M2r(~D3h2!+v31@Ap*{(J>!X<)m6$ey`a1(Xkp}@Ou+j0koM-33Z zVo;?RuD;??dkl&oe8pSGg-m)bU3=uWKu-D?1j#Dv!)1UFuT9ZO8-moi&G?x{!r1ET z(_TPQ{igB1UVqBT{hN54Us}Oh8s||US_(vTWZrZ-3!#D>C^D8h>N24oVNq6ZBKZ#P zm&rr_#ephvpvnn#(t)~MVKv$~1`)^I4jh$}o|qf?*Q*^UDiIwOPpCN#6scZEr4wqb z14W|>9c3Xo;svTb#sp>)jbU`$Ji;|`L?dTZM|CDtwPU>9O6K1!msSD)!s@K90V*4v zE}u{r94N8`I!bI;Iat6KfrU}*RN3O7qlTo@g%gVm2Z|b{jw+&jr8-d5oODz?#Tx8D zQTx$R6A0DbfjU)TZE3?5lD(_zz#Vf$6R3)#y!$F#s+9H_AHRwP*M9vo+lC^!;CSmj zt^)4SQs4uPVkbhBgGhuo!_L}_Gi^+YKBvt&Y~ynx-QU;E&E3A;>lF4|$-YP2$gf4v zc+0dFmRnpxtNDvCbyM1}G_n!38`scL9r7_^joWMzT^8nZ+%!#4kS@^tNDa4WIoCu5 zhSh!oToM4P!)m}~D&*q=KzdLENCgK4qq*pJu-O$*ZINa=~Ksf>*2D?iIB$smcZ$1I2J*fe1RC$U8fGRdFrKC8Q1%Rp_EE+{QDF9UI)BsW6 zJ`(_Pv($ieqIg>XsB=*RL_J#1;Oqw@|-&%v6jvKex_U~bX zsv2-1S*(Vyq5X7PFN`m+SyXP+o4*b94*@~pM!WQIp*FmD+cvtI)-|Q%nM=HyP8?|G z?rc=Gw5lgETr22yBuo1cjiO>q2A_iBcv#w!lCh&lk1NQ+&co=_*xc&0yLHq~hopGw zQ|unxhKS-dp~RB9v^Db}jdcsbShQMgAWe?o5~*2;s{M=r?lHk*E9Kg1qN67-jCSAk zqs{t;*A&BNxJyPq)!I`eQ0A7_g>KXtE223+3^U&m3j&mBU33A;qyT4-`A^+57J@+v znC1yVLP4YNxGjryI(E~>!OJ81Dsd}C0pQip1r05vCft$ZMD4bjUtfz0RsIDH?M4mT zVN=hxh-XoV*wW}Gil7YhcB|ds>)WhDNvmSt?GSHw55LPP%UsTN`(zXwcQ%}kJW00%SX!~>{61E|C zg(?i9M7C@B*m6J&~&mNv+I25%GDOKESDx6WWO# z{PsFF!uN-<7%yscL1`jqjRRiZaMv2Ud*yWOD>u~2D5rPo$86xDUR}qhZDb8RhOgr*HnNbA7^3U* zvKt83>Kx)Ehx+UIv5nBw-`V^Ricy%&YivTsKFsD(n;4$?%;p0(0Y5F9zq$#lseQA- zi49QuEQ?eVA^LUf{zv@?hfG0QHYU{&2tpu4TP6b`2!v~|%Rsm~64(>k+J=uM;mC*( z1Whs+0&F;fb7U|a3544hwZC2q-HhxM5n^ArKSU6uW?S9fjj;Clw*VI6{y1-K6X8#2 zEx;{_56NM5y^^#W$^50ws1RMQ>J=hApRe1@x;A;R+h%Xnj0zmq)9#kuv&Q?atU^s8 zBNrZu_H!vNV`p`^&lXnO_zX;hZj5+7@3=)o*hp2 z|Kx>GoZ^pU9Oi=4&H-$L*bJ3qnr`tYLzOn#XvX!1E(y&*By>=?(UP{+)iC#2=rnafZJ@g+{=g!9^FBV8=Y`G`V?J_=Y;_o*8D)8q6m_Po)@rMn% z;MaE#PW|=$#GAgm(s$QSL^^HgyUiz_1aCy&jXv?9??Czvgt@?XHTte5`8@s*Swl9m zg2+VS-gG`Fm-R6o+=N{xL%q!-ytT!{DI4@8ndm6C0)u;`&ui-d?>)ruRX-~prrt-_ z;MugHMOVirw1gtuL#X+eQf9?LlWo`OQ_EWb1#3P#(5rN`Z|#FrTOgG=`I_KjB&BM9 zFk*Afe(VsP(TsXHa~NVyzU)ZsBvBEdoEE=?j7h7hzty{lX-Lj~i{blQP-G~TG}YMJM`W0t}rdMpG_it#u~bKI8|tv(S(# z6lUwqap`6@Uwy;NWW}ok&(XqD=}LZQI~(fp(rVs&2bMnhs=Gzt#SM9{>-o0WRnq;dDXg3oA&Z z#o8sHVN3<-8GH+!nS0yjhTKkq?F>9I^EL~MT?2goRwrEecz};%El+5)8FC4Y_O&KP z)HEC=8AiX)-QQttTkTd!k00xLeB5dQy2EK+raz#~g`~|DgkNyj%^aD|-FL7+KKmWk z)T7o)zWyDS=5g`{>9%E519%lr$btB}NI$}}ReIvD z%R-z>$+lk3KYo|>8Zil@fXey1nE6Eh{zU?M{+P^PBqFxz6M@||CUW8hi4SV-$l2FS5gPAq=qE04<;gnArm>GzrZP(>P{z((EPMz;Di@6fyQB{27kc!ur;~vfYDjHchEx@6z|O9 zL*8RupFL$~3;#8PygThZ8~}t(${^QH+k^o10AkcoN2Q@mg>-=503SQ^Z*}GYf_a@R z{?mIbD4?IkCNmzL3^>%UFNQ|TIeVWqj3UYXh{HKN6ZqQu*rA(I4?dCI*G?URxFqg6 zxB&&lYgh5{@3Zh~VdxjgX>WRvFMFRoJO0NvArXuqdIie;Hxx`R9i_QLDR`psl9~|# zu4IGy_q7f#H|#=cKkt0x5WMw4N~ToWo*U@LDa`};EhyfwDm8y8r)A3E>=t5JCtcoO|!N zf6ux1hDt0nLTF?&8nIaZ%;HA*d&{56-r3BuWn-UMwoJ1|l)p2Jg+`lLem3tBK7O~* z@rBMG>PzyplAs#7i;{*;8y=A>|6%?72Yz3d2z+G^;hvCvXt*cj6*SyU2urE`4@jRZ zj3Vi)NJtjjqwm61(CgO+xz?@?evXVO)&$2o;YSRxspIJfbLEm{WJ4DFcIUzGDFLQ| z$e+zst|OMboQl?puKEw+qArYChVlVe<}Q)lsnLHded;w zVwONkjzXOD<`MQkK%}k9SMI2Zq9@!BI`DL zrLszN`^M#N0H&Km$uy?tXfz9(D+hws@syiJxqmviq0pMv@i-yfffnRR+0~KWSs?PF zSS9U!7vp+1u2Dg)mG3CJ}1hCc9!di!{pjN zyw5J`aD6wuwgn-tqNWbnko*Dxdn9{6FTq9#Sl=}g{FVxCrQFn2)XX98U4R@rF4b{J z*N8c|S5E#rxw)t%=Vd3_viubR*j;S3xv@xr?4N{gp%|d?NAIio zZp%7WU&8xQ1&&-g3RT{X(sEuJ(Lv;(w`jrnAUnBv@FoYXpv6M(ol;gb5P1=8x1Fe{ zQZ@2Sdfx)~hl=3I$!t$0!`^%3Rx96+AxHMJX4_emf!u@&e;)IwHsqCsKRRXa(}wjv zc!w$)0@y*NFH)B!)P*Ui4>}nxFn-ZfHDd$il~iOe{RyXXY=c}>Be@`XvW?2DqCfsr z(7QoUXe1aatEtFq^oOBxehqSLBe^iSB^A-qpORViWzn17pThkizQJEHs#tC{ojUEK zqA*^hj-n4sI}hZ^d0XiqUD=zSm#AAp# zWXd-|FxX7dCLm_aaRQL22S z49ir69=?-?S*L2B9l^*2A1R7colrIAY2`zx3Ee|9R~2bHqv*GauKpUj)4DD`=~&W~ zW4|#15jq27enMc2KO&!e%l5R@PNl{V`*Fv)S~IoT*{0XshX0p0KSvsz0*D?TVogvX ze*1A*!XtyJueiXZ)l5R5?P-+G&vj0wdSW)3`8u}`k)R88-xu{Hfd|i)ZP|e>}%FS`JyJW_%=ui_BVWT z*&a61;AxAqBIKuoYv?THtvofJbs`MbxZGS2`B2j*wV?|~?hK?h#w~Ouxz2Ov5}K$j zK8~AMdPA4V?<)rAO5D;Uc7)ngAitxbI+#gu1+szjDig-LH~cJ{|K<>|1ZEEe>npz4EuKi+x{QnT_|dt;Q+M%#yLJ(7hwE<1$c}h(jh## z;yvg|Z9!@vgM5#F)m}n%Yft)UY;_t8DGrOzq$08mqBdG1I{Wvu_Sa8TI_^oCeDim0 zqK#ThMKtWBm$eH$a+x!z;eGGEsJ%T1yq(HNWgY!S`Ith@BJ?sTn}K9Fl}x6RZjh`q zgV^u@i(Q5l1TB6gj3A#Gs1f9W?LW%1#>ZvvEsq_q>qIAk@*MbIF?@s=>|WUpXW_q` z6R5LWHa%1l61dLIPgCpc@eOO&Ne&T(v4nQ5&_$1Cz*BBG618UqHE5veXXqc-4zFeX z7UtWNyisWO#2945eo-Dw4X4NDVuV5ql)A|S`aMx@l+vBB8MZAtjm|v$bFI7^V<|q- zSs<^8AhxCV!1hF?Q}#GV4&<@pJ6?#Vsb49FVBVk~;3~t}I@!2|^!R~| z3Qej+#9LD^=BBRNLf4dms_#xq9bf4b zoI?d?{=;u1WsOr<51mrMlohD39ywWR${I*nL&jIpC}4raejlQ+zed*w&IIS)e_R_% zpXtLl4?~kqy$lRp=z{MQCiH43zBXsc@x!dz_0I+5@56Za-FH8du18pv>xKm+{0J<* za~F{LM_Av8R~9^~T~WX!VmmIlbmqE9w-Ecur*q52%4OcpG;MtoX{wq`HAEcZgX&m6 z<6T4{JB7}^0imBERB)SHO8!I)?V6)fQ&-Wtk$=N(WWnvL?~;!Btbd2@=j-aGA-OBg zkn#DbZS{OdZGR30(_ZPU?QI*$(R?;)!XFj?s_hHWj@tgKs4m3DwVgo=bIK%$T-9Ku zhwsER3C36D%5cW5;V8$PIP%U>l#lf^Egv89%~96hby)@Z?I>OhHMN4&9L38B+Ct-$ zS45J5$Jnm61;}MXRhQ97#zZ!5CO=V@1lHYY>y|FtnqayYH@Vbl2dHusH)l6j< zg;m!|Y?O6xB8@<4CBZ1qSjxK!-Z1+KT3IC?DT`3f^%YZv@^DtnUKEj>4bg(z_s~7> z$|!TWlq2_#ua6X15Y*{ot42kX?Zjq`2v1{@bB|5@;yU~wueN^>)s|83)t=<>>X4p zteeqq(}h@ktJIKax~Zl`dZ^e4h3%0{pNCLJkoq^8v|3j`VsAe|Oodo#yQh%Jg=pMU zPLTHsF-PY$rw4Dtu~Lk*bN;7bIvcwd!O}VL&AyGNRPupx{>%9#34AY<=FJ3y9_&hu zV#OFZVr_LpId?&>QdiONv5iNA--tCnR@3t3rIdPNFIoxdMG7t4lksH0adt?1!!=BM zt9N7Mu_wkV^MJgn7g=$fl{_xt(>?j0g@VAEFxG{fJILLd4lcfS2`EQj^MIzdlC=LLY}*bJ~)u1?CMR&HO}|;??Wn2 zu)eM{UXZpYS-*h`{^_GhBOgx}Dn9ai(|t2U{LKgCjgxFoe_Ib!T2ez64&ez996IrR z3^gU1nvRrYzV!jw3u&K)pJPK37OfmQ*v2?-a_P;K&&l1B?BHPUOISHlO{Ya6beky! z2mycNCfFa^OQ_FmD%=!49f7P5r_-@qwaXE%64b3-WZEeNl~Nbf)`I^#sLf8FN{W(k zV^5-iIKzEs7x@K2*_g}DRP|^a6n6Egfsf8IvmxNLMxoN*L-V$e!pu-}C=m{dWeJuO z=NBO4>SWA;&aXi@)x7!+J0J4(yDkKsu;BLmII`k2s~eS2f<(Ca$&cd@I_Pg#6q=YD z&=N%y-^xBvdH8=WbGHMW?TIt6ws5p7`CeDllB{r*`VV=BxSe4mJ68BVrfcGx!xfA0 zIn))x{cH<)=L|cvNAeX%d{5Ew?sA9HoVPM=saVmk?(GoZ*!NbK@)+sKbNEmiV4>xl1lYJU_ z%7hET-;Yfz`A4xSqF6?-F{+Ub-kEF=KsX@ z9K9?1MeP)-q9*0iU2$f4o7%PXqINCa9+yoxLRGLSDVN^3FKbhqsJJC6Zrv0&bel^1 zYDI~9oJX$z#Co@#wi5g3!-VB;+mlidq&#LNX>|@;(+A%meb2GoB!cO?mR*TKhf760 zpO7#7L0|uZivt^9I8EU6&f})iry9jD-WkJ@6^SFEmk67QqTRu^mjbi=odnI4CUd~wOIb&_-yq{_x zCfK(qpAW4+8}lAwqwnZ!_4HTq{Bk7bpUzPYuumn(_c zL{rnkSiV@bSC{Ivhh6I!E@I&IylzIR@e;- zZkuDsf%9xX*PD@~>^$q|T9iwgU0`*t>AA#m0Rv4!?h|Z)B~DHaz}NcRism?Wd@hZBLb< z3iRbD}KR&8W#uCw{gsNyFVQgp7=b5qQbv6O{o&4 zo9u9N$8!(dbheZ@jciV@DZ@Gi^R2<)%5p(kkcUWH=TDA ztpo7!WjZNyU%aSIv<`IM&H92&D`tE2kGp|wcpx3f0Coe}KrZk*kPn;!if)iEi`g}; zY$4c&roml0OQef9Z1SE=rd?#awvRkO8_GDk7)V#z3KX0JWb;MVw{tHzIok@F*ZWR8 z%Vc@ZUGn2a97Ryx*3l{nr8z!JSxnR&KIjYUb=~@U%5>^pvu>q?!m5{&eM(Sj)y+ND ze1<^@XA7iqh}EpQ4@eA8g?f|b0*k8QPg@!eXi$`n>p`AaHFnj?YwB%GQ7L%gB^1I5Tzp zZdpD6MRnP32H&5jfhg{Qa7XSI2BeP9Xy9JBM2n(N4Vah4peR{e|?o!up0yK#J-$zLkgx=aUhbW4m)N^o`WuWXHLi4CQ9K z!)1$dv)ggA8aD;EqoU7dWn{bK#wqqKGau{1q zgE$rfzOR$fzu^;=84&o|B{vI1F1~>mjL?s%czpGA0(4QQZ8wjW$ZoRvH`eMBN6!Do z`na~6K<@v>b|E*fvIf_~!oQARVE98cz5Wi75@?a98YNb&t~G#eAUe=ts&2*T}lyy!{T%mT`)bE#h;HZPWAGUv>GY-*jikBRZG_ zYU~quSwEeOxrT>!mW*|t`Ruc>Eu56HcWkkqLxs~0)dzZ1=t4Rs$hUUUDJ>Dpth+5w zDij%JVyX}qUb`COc~41{qrH4Z)vxi@_9P$72Xc!I%4vcVavUz|b8+*pb`BrPnXjHO z7!=&DnM9skW1si)xsQ)RmF;+k`>k0?SLe+FpWm94boF((EK*#2?~~5g@r~5fX6O#> zH%-9$we7l@iRBq}G+jS<^J!IK+wsU(b$Ry^*K@cX@=THW8#D0L2B?o57Ie3 zeDCle!Gl5G0S}mu{rd&^37`S}$gmr1pRvwF2o1j8bodH|uOKftcLGP*b}u$S<-!Q_6Y0Rt|1dJ=dSgKGrL;(e>O&%Dv{` z&Zy@`Q0{35H>RE&PPyMuE}8uYz6LdceE0`Gft~qS>0tLJkW+u)10EB|?LV--JN`Lo zQ_f1Reapz0a#j^kb?td=YO-G`ssTs1JmuWT2D?HQu3=YL=#I)Ske?kPS>UA>o*!+)~gt}ovuC4b`h z>9%)?%T3(d-X&db!g!hUn2f&3c5q#5ATw{WgF1x1f}VgS;ME|%@X{2&Y$Q$&GLSE+ zo14SU2W}B{Zj6E4gBzbeQt{`DV>)4ee#-e%x`^yI;RR+D#}L_Kf|7b~r2b_q5_XIA zZLxciG6dazhb+7W#dG5s^3g4v`mO$y{C*3@r^12ciX;F;vJGXCZ(j0o~4F zCYRH|ubWilS+j^Jvx__Ii=sxXC8!yDc#uO}J{(0($*j8X*VK*bpT1OYQG$|>De{d% z-5Ef7+-7;h({TvB(jMXk8`T%Jc#U%1I{`zy;2 z?7qz|cI}5(1KwfV4`|y0q2Ux7RbRbiHyZX&_HSr9Jia>DNUjg)V@lj(O@ zo#);pMZ>hOrb&~xyiUHj!@lEs=o8{|mmLtaHAER=D?(PF1rJCHz;B>DFkU%o z?hd_{s@X8^{{b65l`<$&ydu>+p4jhV!TQY%^2J?taLZ=S5SPv%Wp~*`*Mwm5dIik5 zk-=nj1smYnKbYiHV3klCM6Ok^D}4Rwxw%;|tkV^Wx~6_qc5DDn_?RUA1v{@I_3AXT z|1Y+E59LNnR|z3*p{Z_(_6|5#N6$8Kic6Piy~6wb_{*f4WBy;uiSd32i-pxblQ;EtnyI;8AmG}&^W9oRn4VX>p@;ksQ!d>o2O&z$Fw)+Q}? zW0p6q9qo3v6+A|Q8@evU%|5}+ap;;ps!@!ti?QQu8I-F6d6FYcx;sf%BK31;n;>Lz zOC;@6q3pVmEV|i~WhA^3N(l~5&8uW*yT&dfS1QpP!7d1tTZ*Bjf=a+UiBKC$%%7+R1s%$ejo5mmbBgh#%H8@6Z=GtI&*m_K@w{ zYWYZ5Sx=*v{`8Doe8?`C=mG}%G|m!Z`Fx6YYB_bB3+_+Ihj1s#3w`Vbjkkf4s$F2@ znreahASju2dfe#nIL1W@W<_lk+3|?&G!E9BTV;Ns4Y%?;DfCs5bm~3Za9kQi;?65N5m9^K0m;x8qiLeL8g5i_I`1i0;dP=KV~JD2omsw_3n@^;=FuvyX{E6OWjH& zStOI6u>CxfkU(mrm_CAbrD?;+mM82`*XAO*`~<_%`7NaBQ#Qu+Z4-I>DU1~Zek5N! zWkuJA@00SU>|j^(Nz%TWo!~m(NZosID0o&jpLtI6A4rbIw`%ViU?g8xBgmq~qZs*{&mbPpumgHfPlp>@YI0I6OwDp`@T1z{qZj@`tqiEz^KZZo33{5+ zoiPqg$!XUvP;BHdkkQfBy~U_{BYDktKDcvM>G!EhJ+q6 zv{3egxLea3e7bqLlSkZ|}*%%#c_6W`M*)seh>#jGh4LPg8fkUlRl;ihWHt1sDZy_1n~`W%6>rbrt?7q^vij6$*32U>7@sz}ma zvQIkyr%gk>l;OA6q-4ktbQ8=udB_63m>RAov zlzvyGaf4jvL zVdW^E$7fAzUL`ABxK0Cx{NmJ#Ov6czPCPm8!u4^TK8*b3!u1?biUi47 zIO1ksl}j^>2Sa|AM{wn*J~ItxpF=I6%W%C4_Wmddcnip&_>c{hLU7R zcT}X?E7H5`rGFhtet@Iv9xJ)-%C&dBbAVL4a>2G%riM+SErT2;9r=l|fw|nll;!J< zm~VlJt(ryHl((0xx{7DMCW2Ex)O}4$d=-t{(fH;`D0C&Sj{Q*F^XF@^2L=~znXQ*Fvrrp$B$jHJ687v62}y*dS2bd4X3)q`7;A5*;s(>YS! ze2=8Maa}rQKnCZ`_S5Y(cHuV1%s6opIpW4eyB=6YdNk#{UE7(7*pwUUI&l@THRbxL zGNqTbiUHSoHYusF(q4Ti)(eR`Dc={6mXmVH4v;lUdgklNuT8lT!Otq72dv3JpIF$} zzNXRM->&Obn5x6@*ah9ca%*ytPTTTRh$Cs=1uIF*MAA;mUri*lnsFhneUr&o&A9dv z-VYx;l$Fa5pnep!{KdYSE@$PuS%2g340wtrbEw`il5RVELLGmvbNsm8F`3RRD`ye! z=3M{Qt`NGt1+9$gZ8J%Db8bkJKk}Xv=|Rg*w&wvbA7Zspw*a$il?7%H)jMpshMp1n zXI1UVq)>2RHiIJQgR7)ttUalU#&W|sNPs&xCE%!lEVF)iGr0XuLq&TeucBQ8W`DY5^~41$cMl}rxO4u4UHYLFUaWsQ z@u5F%kJl*&<+zg{!33jNBroBPs9K=%``jUZEx6vUwYSMDEjVGw@fnV%JZfkXvxYT3 zEA_HJI$BT6vpXR}x55>fwf~U0(x2qF;QF?ikI5a{xy_z51B)j4^$=3sg7a}rh$S6b za#H8@eIM1%xzx^Xr>?19=dl^4>@bXuA+asFvHA}&1JFkThAMiQ62uy?p3Zf*Z(&f> z_K{)Rp8oClj!+<~Ns)Lnm^^ODS^RrLGBi9@VLDBRX>{H?jWpp9g;N^Ku_>)MAM16D zo=9m6Xy&cwysW*utj<)zN zdXR{^a@@(|hNHG|{&6m8$#VUA@4@*YrSZn#g3c)PaO$C;F6d(r8U$5*O~qr9^;1iq zw#B?N>|W?caP>_mt66T=*eT#+DSTP(a})gPiFSvzAc(Rt7$hBSnmVDWtc4?e+{%3+ zsde+ig`0QyX=<>6R|p(3e@EI+prE5}(!Prd6*T31{si(lI1+@_;f4Xbl z?shbs{Og=<(L*#SHl@3riza6|&c_x75k;Zvg&46J4W*3gV`F{lrrX-4Pe8qo^@@*3r-w;MNg6m6^8%SXpe#0!NdXex4rIar z?`46EoDj%_gZcuS`VV2Efw;s#CJ+$r1u{7mwm>H1Ngxvkg!&F)in14e;xSGL`GVdv_>v3RtpWC=&{#6%Ao#0LihC zn=_R04+>$bhlMbPr9&BapnOjV6A#2~9LfaR@Z-I0C{vg|l=0n#05gX&GLQ>o1Bt*A zAQVV}dlVp9hcPUW^C*Z(24av91CRy80i}@10=zy)WT5Hi;0H)!hB0A)0b#iVGZ3#$ zz)y*J7_$iov+kv@n?0pi++Fz!H%KS}|RU4of7pfGi)jY&&I3f~>hNC3NZI8zE51nLDO z0AavcU_0QsFO(_T8_MK=8_FaCZn>dM@xf5044Al5llriJiZN&K+HEI7y}@EJAz?> z%tIrXcp&-*cm@n7M=*_3yUR!>8c1n2l8FL}-A6K+Ky0g#j0B`}BbgYW z)MF%*1w`4dROJhY6Zm|e zoeQJ(i6(fH2^~Ver_P-6&I+*NkY;(e!g8mJF0g`-e0i(FlAWxqLnHA0v6Tw1imsd> z7Kq%)Z!0Y2v^iKykU2R@VJRn*z)C~jVvM1{lmSW9^R3=J7?xnC4TMAgE zC=A(CVJV9<8+aKg5c$QhXSF+(95MDyfzXzb<%?FDr$A@Q5>!aWC5YL%Pqx|bJIu_kgQ$Q0Q% z;9yN#&eMgId2wC`SuZZsrA?4MP^m2XBW%S`Lf&l8^=fKZPA^k&NpjkAX)Xp5+<_Bq zMM(~6|6~VEbW&lJ<37bn%biqO?ci5B>Fza-d-t^tn&+g^PU^MJ!T&#Kf9Br~aZV53 z&V&W5cLY#I`gP>2ws>!hTRc!tsZ!i) z8TXsiy_WF?%`eTjG5)yt{7fYiNFAP6G7+E|8JWxsP}n_cmw=+t)@}l2L3e|?faZgG zfR=!IfmVP*53hB*HH2vk>J195sWt!O zskRWbGiWJjE6_?%XalvZJcMZn>JRD-8VcGGGz!!WG!C>IXd);k^V&2}=oqzGpvZCe zd{9~>MWF3L%RxKXaDgwAGEm}cJ#PZ$d4_#Uaot(6gZI-672H zpnjnDKqXLG$B_p=?#zvI;R??|4k!jn$%`&rmkGtkF?|CSKsDfg0<$mR4;X+TAOeU1 z%Hgd7r~+yL_Gi=}-~;#p0e}Fw{d{nq4|mw5cNl~sfLI_3m;uBCDL^ui0Hl#uyK&tI zC1O%d0c4;G2*>0}|9ln=W8611Tzlbqt%>aD#$9>bQBY0kB3 z?a^ctO|<9GzAoI z4X(`qtpd#fg%!HC5cDBv3FrgR3ed{hT2n0(5X{^M!wd8ts6Xgmpa#$i&@j-upi!WA zK;xV=nf%#<`v`;Zik{qE7te!pdvQ%%>V}kXve}Po*Uop@a3&2%2etzl%Z8Kl^IFe8 z=-->Gad)X8y$5lm>5_qA%vy4E5GOWG!)2y&*(Mv8`2hW^q*^OE@5K#nbJod5KVzyJ z*rkowHTCQk6*PcBVT>C&>c{ClSX}x7=(G%TX%uCuJa{M59b;S_vrQ0~G8 zd7}Wl8v>{T+kG%1OGFE=i_9C0x=i>r$ohj#OM$@{;$J5#HIfZzkPWMsb!Ygxghhi% zOMw=nS6u*cVA4ODGoe0!Hi?bGHPo{`(!tJh`jG0v&HW$DrbS?uks(@6^r*z8JMV}l zu+Eb=82@7GiK~uNzU1PMwMQt_hA^x(Hi2$h7RW3CFBkAl3}h;bM>z(W=uu24cxN%# z_+VWT24s&I#pK{V8r5F~O2-#}$obKA2NdN~2rmuP4Q^iiD27LPL2!2m=s0DIcxx1s z1xI%p5!M6&KMi5FfX0z!HR(z$1^q=~6Kc*P#fYR5OYRho@}Z zm*bi$SM<5CTqL>@*Si502`on#xhM$<5hcPc9`|X8Bo;UYc{=ijftP`>YEYV4;77rq z=SABn#{2bAOb{IN;TQpjd>Rm_Cjw%T$^ak;_mwEVDl83CAe#tTHw5ZNa{+k3qoJq16WG|`avK_=aC?QO$P9t0Q^OCp5x;CKqO0v-Zs?mz>O zt7u%W1f^0mlqu_QH;l|Dx#iT*L2AL>C z7<5juxxqso1Zp50fK;a=;6wxzjYO=4+YGn`B4=yCXK|ejUOo*Jo-2^U-Qas6&`Pue z0b!IwrWp19E@bFhKMd3delj7S1zH8_iIQA`IJ|9vHYO4Q$UrhYW+2j1crF9Yg}^58 z1q5zD0#eY51;|vwt(y7)Jqy`b@O&U6%tlop0SUM-f_p3?ibjN4BajgIFGG0gfEV1| zV^Km#L?L4v#zcY{j#MVV^LBv2y&r_CkUL)p`J-xr;LadWFO*OWA`XLGI;c1J+YwO_ z{FH(hgzFsm&B1jQ{AR;X3BV$OLGbGa1i()yO%V7owEnA5bP;fv0Z(c0Tuph%Svla3 zKv-IQ2p|J;GeA!vN2Q>F2p|P+0wR^+CmQ#~G%<+44dKKCKDaMNxCUgx4}N^Wiv{(C zY%b(%*$5y4%q(Cna^#DEGI57i*3C5t&6+$Kg?w)X8GZUGBn-4Nper`w<6NLo$Ba+aVQA{;F`@ypx1X$Ej z6gfxv*p?x4Ow4tt z%#Hra?sAOZjeqj`RB(*pU%Z*%h5n1T54^~K@t%Pf`!Am9FOEsL!Py!`%P^LQ9JBk6 ze?}YyUiQCuUxJtaFJ9JDj;SpFr{7rD*370`|KzO%FTI`zy9WL9Ytov@t7kfRAx&E| zz9^l>f3Jh*|1aKd@C-7yxkr23J~-jA59W8^3DEX7$M^y~AORzRNMIhY8rT8s0}6ps z;34o5XnBWYe1JhfATSn~2_yg;fE~cMz$xGoAOlr*P?+whxeh>2zygE=(LgM)1XvGz z2pv;D! zhd{IY9ODJ_0W831APR^DmIE7rPl2z2LZAe=2e?+kAK(WFKqxR3m0e}RI1||dXKnjon&qruqfB;w?q5enWA{vMXl7UUY4qzW}7&r%%0Odd>Py@8ALUjTDfC&f! z!hy-a3}6Yc9>@T`22KHGz%zh-%rV}8A7FTl`VYayOkg>X24n)+Kp}7exC2xJ?oZ$m z@B`GqP#^-B3d{pm0vmu&fvQH4q4l2BLs@ zKq9c=IqE+X7umpJ;4DxAlmkxy_ZkEO^aKV0LxE^uHjn_M06Tyz;1F;Lkb!ET^$RpK zU=Uyd#saSci-2U{eIWA%>OTh;g+LKd3dq1Spyf-na$pcJ6bJ)e2NnSvfKP#J;22N@ z+yov1Of3=(bOZVTI$$U;0hkFa0#*ZQz~?snd=2CSXMqynCh!bs3v*C6U=R=pj0I)@ zalmpQ1xN?7fIQ$7PzqE4&j5Fq){HmM2QUC(Kol?!NC4IYw(a=Y2OI{9fEz$1Py@8a zyyF850wiE8K>wCH=_b(6fjr;>P!3cB%`i1}0O+3@bR_UP5D%;dGJrgwv`K3l^AH#A zZpbO1210=-APz_dJ^=OsCxG99dw@IUFCTyh=-*f;jRQ>t(wz5SgBAkCKsitaxHm(o z0BRtt*^t)EWLzu)HUSyH*FYgq3fu#j=B*h|z#lLHBY`Mj5wNLw>w_eSo6^EPe8Jmq zy!p;MLk`NLxF#K1dyZy2fkGb32;b3EZ@EhN2OeihkstTUL6@1_&SqU_n@nP@=q7ne z-K7E2ed)R6ZtiUEYu1LQP%X|f2$-m@1RlLfel2n1JAXTU;Ockz*P(`X{sFKO%<6L`} zGBV$_b-N}$YKhGMlxx={UY$mEwrbsul%3)_Gzrjzk)!?Lo~+3vJM*}9?MpQ^8aKgR zU4@glAxt@mmOkE*4dKMRq-j}S%!bOxmf$U$& zwHutLFV&apWqpOdQeUO7*4OA6gPXz2AQ&V=pdrW*Y6vrg8zKymhA2avVH4@`C48SU z$i(GCT=*G-$a$9L$(Tu8I9!w&8PX=6Yu8CKMVV%pVob57I8(f7i7CO9Xi7GvnR3YH zD_lEUmB~eHA$p6w#erg|7$e4s@!}FOK}-~r#kFFJxJi`73b9hG605};k&(P5KgnMT zlES2LDME^rqNHePh7=>kN_kSL)E2euYktK%&Kzxi(>%wF1`H!y1jrzME8kBQt=gdZ zP4kzgTGLc$iL&;y3WEhn7$TezeiLpBjF#0-(Z*_%w41b_YhP$v>U!y{x=`I--2vTA z<37_((;|!A@_~iPV3=40+LR|zZCdwyqrJ*U^}A}1<{|?B6Tv^$OcvG&nZj-%3-y;H zJkSo(57Un}{ARdsAjV%!k4!I2Z-~1^n`AbRu^^yqhRFoc@SV|?cB;;))anHFLG=l> zR+FSTuL%-fAyWpl?qS=jJ*n-j3)4mG;&r=pf9js;JoFFrO%1OaHW+?1+%?n~yo|$* zQ;Zvog~mt5<|c2GzsX`6iQ>O%3K!RipNN~Ka%qS8hWVB`!1Af3z;em*yQQnOrdx@maL zNMW^hhxRk=SK15OTCJO|n{JqHq3$c)ce-o3=eo}N0R060Z2d?2FZG4`OZqkjm0^;h zz))>yW9(+s8$*oKj7yC<#xF8pKcHWwD1ONx{+;sf9V+e8KE(u?@Do zYMEx4X<2SrWl6VWTYk1&w)|=7YYn!>S#8!W)|=M9tVn(l!>}$4vw_d&ukg3|U8;jB z7j-*zU-dicPt?WgKhzJ^tu+=+ux5;Aye3LBQ!__1U$aP)pjn|=quHQI(`?gxqRG^J zsoAeNs5z!NqxnU1jaIA;Z?|z3nxmU`5_$>)1VM-r-W28u@xm%$ldx6zS~w&e6K)6t zw3D<6+HKk!T320wE<`s&m#4d`3(!aFv-Do5tQCf>hVKnO8}=IiFt#?mV*1c@*(6Bs zNnc18rN5=7=5A(xv)UYFo@Ab3e#<=1{GNF;O5jVg?JM&U^J#OfxvRxw2}23&Q}WMP zTUh<9dh1Bk;XLaK>w4=R>p|-!>pkmJS{h{xQ-acH#dqQd@~`l7`2>DFznA}+|DC_b zKjB-c+F>{|t2(PWjan0`NkkcZp!rzyz2-JD+fz^rW?`7{iV!aNw$@!SJTj<_i;QcG zUm6REOFTEuI}+*DzzG*z2wOm3pP=qY-MKBBMaF9wK$Xb=O%ATdk~7bC?e zafY*}(|%5Sd779mW{8<$mY6N(ig{w8cuFi1i^Wp0OzHo$_cM~4#9~DEmVA^kfR_X` zk3gFgiot*m1#}>YmExo&Qi7B$t(7)OY0`EnL)tB6N#9E+r3=zc=>evKW@b-w7jtj( zV6)b2H3yr=m?xv0-!{K%PBw2aZ!>>p-e=A=A2XjdUow}O@0hF1FU{_jwiZ8&Xc=x9 zW0_=`VTrZOw-C#>mctg?3ClT)+8SeBXx(8gwqCa~l?)T+$}lbYKz;FdB@KG0+%gOfV)J*BVodn~Z73bmMkohB4EaZ!Dt? zsa+>OQ;;dl6mE(zMPkl~cFr0prYtgji!xI<+LNEsqIjiENoY+=8qF279c@QT%6GP# zhIzwHa!0HAU-QOh=@V(6bXtQCmi!qHUH9mR&O}7c7%d z&Fie`)~~FGtrxB3*5|Z)Ve0_HH>$e_bco^n1b#OEE;?8q|092cpQM_lTBJ%<)o42E zdt>yg(GM_$U<%DMR2f>KfMSj7j7N=Ej1P=Km>u_!PD{9c?(M}+;s9}&NJcK<{QK=O z?=`Qm-lkFEA<|MBBYJWKKcC-)(fJ~j5mB{V^^xiV*#^%aWO8n95$aeqIRnqOjuZnx6*60;Fvt$l8k2h;AlP$9> z3oKhKdn`vSCoIn`Ev+3fO=zt{F}!TV0CU;;hxNYoZ)>fU@pWO&Vt{GEd-2_%NtyUD z{1pBT3^WUR@{2Lrtl-!1Dg0)h@H_ZS{y+SFJ{KuJjsm*Cmy<2;a%Nk(>XE8e#j3lh z&#JGhH)s!Py)k=u>wWaTdOy8CW{`PG1I*LsqZCi+`xu5BUNMX@j5AC$Ofl>=c$m7F zdYS@|zY(U%rdg(Upk=&oN;mDtp!CATihfWjQZc05z;NP*0Yt)x@vfBU938R=dBJg= zN~Idf&FpSwF+g~kz0E$*CHznzQRL`awE1*%E;;%f7nNpDviSnnj>MvfjpC_XBQoc|sdOH}D(#pk#vQB{-u zpL1QBNa`qZ{co;a*EDsGI!~RC3HlU@vj{U@iMmuRtE<&+8h0`zlk3zaL^Bc--&{<4 zdo+77&7IbiXi7EZ8d+0Kx+icQ+XV=`V8QgZSa?rJ5w=rRhRh$(x>viGf-CgSfm)R| zNE@z=&_-)#ko`4W-!8|r#o7{WskTg8sddpc)p_d%>cVwV&{g8d(FATxdoR7WzK`CZ z57Cd*N9h;p6ZM<)8Du`xMl$sb*N1e=;rg_Q!{oTikZ#B&^K-cN~6a6Py*rTTLD%X~GD7IB2@)qII+tt!n?dwQFv+E1-ho77=yJUplN(fDcnH33km z1dTx>X#zDtng~ri=7vN~vSzI&MY9RoNxEjcW}ol_mII7#v~Ij^k?ykop8m1^fT6c> zGKQ2SV{`Ef@gQc=ix>wViT%*rW2O001(b_GOnA#N$?b+FQD**Yr1_cI!{TKbXNk7F zZCPqbfl~Md)WRamZ9b&Zdog=Ot=dc z$=D?1{m85T!6=={XDgaT7nQH-gsMn&MfC@|wyT;|_fYpoK3_vVH==zOLJMmL9qgIL zU6?Cu6F!IPbX2%1w9*d1Qs$gCNHpAOP#Am}9JthGWcE)6|7+v@@{|Da}%f!8^ zA5|^YgVht&Z>d+SzfzZ}hiPU*&-_Z$8j9pJ;ex zamF4dBZjj*;(4h=>SyMmrqm$f36|F|FKxASu*PFTI%2(MWfEO@CKr)wRq3ivR4<^Z zcTq3Vtk-;@nIOy-R$@&uQM*LD2D1^xvHXDk% zrE#n=)fi$LXPRo7tE|^{Vk|X?voU9U0X6M}_@nq(bb&e+CoP1Ql_`BARZA}0fPB#w&{A@#};kcolQER+mY=Nn3G7|E>sf9RA48~fo0IKq@(r?mr=}+ml)XS`b zDmThJ83-JTLLs^8kLyeHoWa*{+VIrS*7&}W8220R8vi!V zH+^c_V`_?3>Jf3Clr8-teNDO~bN!6HEPX9Kt)bRfv_mG_g~>q?w8R+yITY_gezEGY z$_pJ|rCz2^Ro_L6bb}H&1|9t{SqASmonR7XY3FHIX~&@@?A0ICpVa@PzplTl|6AX} zpf-#)j5oYzz{A>xFASB27f>Ze8pjw{8b5(Pb;>7+|BMIcO7WpjQ1y z%9RSG%hDgxUs9Fy5-S@Ivk$SY;&O>`HP_W6il2i{l8mM1cC?COa`aEGo$-GgSC*(Y ztMXK5RWep`2K7jFIL47&_0Q^ftk)``7sGZ!UfsrZY9A&<3k#tKrwBV?Gokj9GNGKz zKh1U0_tC1gl6JWE6>SuqwzSK&blLhTmikAu1z1`Cjs@FI?Mp1$n(4agdgyxV0x^R{ z6V)27{Rd|_w;ma~FLnELM|1_clUUi_(!E5}Xr}L`?}>RWP#><3Cg)4JP8~C_%*)mv zMXNcDI{Q<9TTd-1e&pj{x$ed|!!k^9?;Aced~LW0i$ImKXjefw{>6CNc-45#c+1$| zG{~ej=}acmSVa$xqgE60YCPA2#BSmIx_d#NQHwfpxwukXjUKr{{9Mez!YLm^evw#A ze%``$@#qXYNdQKEI_pJCiDbnKu6_4>sZ5eF5mcf+s-f;MW{1M#i(w_u97 zHQzPgH!~JrvT--pzDYDD!3XEKQ7!zeDky-V))?}3I@i8wCT6`t@~VyV!O^xd7iKqk zP{<8z6~)g&wXTE$lTC&YObNSG!_;flSJVSFv6@dcm(kNhuu@qLyU1bG&m&b@jKfoRp|_nqlbL#D>{&m=KDE(U(F2W|#`$rO-vYK)X_#ru|ym zN2k%9K|c@I&(P1;uhPG-{~YU_WBOS#=YozdYVgjiu2#^|lW9^oL?Y`+ODwXbUvwZCfn>L%&_z(kmd zNnUMu-SCOwV`B&LwAciTVNn_fmF7=#A4@3aY*(uM80( zb%we?y%YgYhpFaU-BaB<{eAr^m?E;U9O-H_L33Dc{K)teqir8FyLU}1OwPquml0h= zm1q)&i{r(q;vDf^w7ZSs$7prmh$qEy(g)I~(nD#mc@NC#lz~)6_fEpQ#UEY91l%M@`j08|bb5 zLVHbnU)xOAO)u)#>9^>2=y&To7)BZ97@iq68eL7TOr0>^#fUqk4d&(;{Uz&nvF||?+QjJs1SG88ZRPWH_36-A0cI}TC_(a`&ohMcpJUP;|b$45`p1?@;jlKZ2 z-`*g??ipiPZ1~P_*zg+0`vT)j<95?N(^IjlG{$`1e9OuNx-#L2%7^a{wLM0~t4FJs zK=a*q1>!le1dFT(m=c;w9#SW%7j$p~wC_>q*sn|R(rSrFJEgCs!_pb)s&rR+ zj3KC{xxKl&xlcEYL3;BLb13wOiRLKeVU9V@yb$KDRu*qde`4Frbs>dIxy~)<0;|Hp zSbfQ>4>7JIqj9dv60|dakS{=2yTRY#AM($5H&shjTUAF@Pt|zU8>+dg)v67u576d5 zSM5`MOP+7Q!>B{mW6(Kb)JxSLqAwm$A5)*flBraE1FAtMsN-s^k>1tVG4>-y_P>bB}W)_n$R z=t12h%oyGDZ(*QWtWVP0F{xj$=^yINhF~maCmLoMQZS>xW}Ic5Yn*RfY<$nS!nn$4 zH*Pd;HEzS){u%V&y~b~h2cec;HOiQz>9W@!(?lQ?wI!x?rYuu|Nrpw;Pqf0uwn$mr z7s8fyRRIm89CD3WOPK1IEB#)x9+{G^;R`|EY-jG;6Oh;Q`Bh0k!#{%k%^}MwNIy<#kS5X~xlPi-3 ztD!630*l9vFr@V619%OLDMMfw7z4A?Yy1q%s|#RUN`yUS1NJkv^PllwD%O-EHvR@&1FB=Hld57EByXzj zs;aSGXsPy4`(U9qNUc!^VkRAn<;n~!SQe?@!wjB^9`XtL$bR)i|8Y_)K%)g z)y*`vRvK?jSJ*NKW7RrDGg>oF6RmkuvjBF@WX(F*lRtt@bFb!*<_Prc^P1l^e?V({ ztQgb1U`+3WHIM<;%#r9;QNnbn2k!`pFsi>V5NxCD5x#{P^Ar|q*M%L>c=uzkUPod%@@ipu?CDMH+GJO{}h0N>IT5UTl9g|LAd^!h{akIYI|bS&ZK=q`!+TTHejaM0WI_!=%Ht|zk6!$YM){krGw4~y9WlHM7kW}G-3|A zL7pyOSEwt|-PPUK)#|$IgY~oYYxSS%eT;*lr-UQ(D_~#UY0SdtP+_bz))*NRYw{!y za-cd!ALYD;tj8MaL#$f9G#xe_Go3J$`VVC+``i+gVu2!Y_jDU zw6)gOL9mxhfO&j3#)9M4Utl-HfSv8Ctchl$K~w$za~LvpSSIgK<*UYHcPRntz{hB5 zKdFZ*mZ~|L_cSN44RaM1s>VB^rBu5Y+Q8H_9)_mvSgduxeBK|Ug=MNfQh!zd2Nv}j z>|c(?&gJWdSi=&-1FV;t89QNoeP|4YR`=B84Rz*)m?-5SkDakv+J%n&$ovW{zaPP} z*A+&erPy8Ch;@@IlZSfu#o9iQyj{yJCW(Y=Yl}qJic_t`?9x`PR}aN5Q?sH-k+GK_F1mkp5SSSN9QLZ(onA6PZlg%0COmmhw8@m>H=0fu+ za}ma+QkZvSWrVJVD(_}tEuNS~eXxt+kMUZt48u-Fq-8pWtHqXemJcy*@3(vpOYe^` zVm`10TEj7VN0T|}+_Xtv$`-jnF;Pz9r(*1A& z?AW@-F1DTU4`pnu^+lb zw^2uQAL;f(+xkUUqw4`f;~f1)Oc=jH@9Kp)b`G?dOsc(*w{y6TThFx)vMs{S<631i zVh>cj)5h~KFx^GLcQ6fxEqT1@|Fw12fl*vt8y_G_vYP~Vf`(clz!O>uWCg(AhFl;WinX!(A30tMa={%E>P*kot!oco+d&V1#Z?c9aH zbpuT@r!HbOWBV9F*R{yC(zRBXsqVX;y3%DS3mtGn_h8WQK`vFK$A+?$!nHX}JC%#` zZu6?%cy`LF+$(h{C<$6qqcMNp>E4BCnH#+Op&0K%yJhxe@s;wq>9lHU8P))L22D43 z0_5TMQs>lW)S>pu99 zYt{_5P+L)3HLlP^+f0!8&$eG}H*GI$Ik6m6l)K8k<;jSho2g!x7n#fCPOmJR@N&Q5v^Y!%TkuY09QC+0XFEcX zK+3zSxe{IR^b|!v7}Dd6QdMrhj!>$X%zv4KEmbUCK@ig{D=n#T*l(@jHizx8tqbb? zX}MS=t3#n?o}pfTWglk$8BXb$+QLx={&2SQs_THeghvrxkk;C;9ftDSso92v470Sg zH<%gGz|`8*0fl8a=XDNec0K2IpXnGI>}6~q59lf0&{gE5e^Ic3)HFl9Z#NY3uc3PF zGvB2X6%}lzWj?!O1Y2Puhk@I(x=XrccMZL@?B(w39_=3Qp6vd?y_Q|^45o>U!LsV{N6%dJ4L1`TKz)rkwEWb@Va*GD?>IdCDl+syEfYp5IPR_JQY4U zT^OPNk$7&r=%_v~jf^&}GFQYFan$k%(2_8Po$P+!T9;dYv}OY;4WLZ!wC%V3WXno>oI*1%DSs->?IY|(+2Y2l zd*}r_(8zCc8~^}>(IOP5K^W>B>(tohGq{S;jxB|mI|v7q(Ni37FYGeCJQ~XPGK9~A zo?jC6rYj3qv8=Z|xTgo3gx@>HI}69bcJD#DY;jVad4qgeeFdpiUSCDuaNjqage7pU z$O4iSpGl%(5gq7f8pwS#>OT|JbCYBa(4H8Le(mW3L$-+Obj@D?F#VQEFcfRF*+&ia zwEk&^GX7m4#htfL5Z;q@^m$MCR{Bj`Fb7vk54s~5E zw1Pd6t&GKuU-;X)JJ2e0cZ(Zn1eB4+Szn`r%JcN-kKI{muw;*ijl3b~@*2>nFK=$A=v7}GBm>xG??vq0o(I_7V>T=(Qw4wnwZF@I#Zns-=uw8q(wXs?2r{&a zs}9suZ`WAY6qn{&g;evi>sQxbVAve)0&oyjg-Jx)Z7`O|zD8%IFR@2g^wjhuaP~WS zlC+5@42`tMuc=VAjm8|AzVgo3e!OMKAN81Jo*5mi3yNQV?)2%}=^X}JKw>5-M(h^# z{9@-#qy72`KTVW5x7loV;HPO|ZVet9VxEQPV=3JAb>x^5G*;Ct^(>9RLp^DIr=bL0 zKnwbp7OIFfj(XP6+SA$}y>AK~(^l(lI;A`M{#(*!w#lsiCa7i8;4$yn46xaap&MqJ z07Q2=*Abj;GyCmVI-m0f87T!qYnFW{yT%)Pj9LyltG_xz9i^STXegnjY%m0YfvWpQ z{b$Hn3bnA^am;a!=Ha>HrH+GaPB+z~A#~s@=T7HQNYLM$!LA6J1q+6~x~>j148p*( z&b5t(;il_fR}kWBEOKjYcV~36$utk^+}j{bg;8~5bM4Yv_eF{S@1PA1${3?V0$hWI1`OUpB!MyrnR|k=;zO6j)mUynX7QR zJHnX_rNl2mD0l=IFJQ6J$2Nf98GzC<6yP%x=(ExCBP;%<4t>(a)*9^5NvJPlIqjNt zm35tU6Q$>(^%;EGTWfZN@OHLQc==A@p2;dZ*kp#wKd{Ol%P+Ml_$$LqN*yHun3JYl z)}oFWa%-ysjW!KyYe4WU#DFdKG_C0oL!6MfRsVdd$ue~n{Qo9(8>nZGdO$s*o?yv8 zp`i_O7#$@XHQ~g2>lDyrsGr$v=|6Ej@;Zw+%R6i1j7f5ibWU(Cajtf**X>u&FGP~Hu)yd_nN#-z9Qe2Gbv#-0cDjMN)x3U zHD;VLRhh0Vr_>))&MAM>T;-?8cxeV&(<~3MkF?MB+ZVy{9>wkYnC>t)CEkN2=L>ER zzdBs~MxD>)*@v6yzWP*sp@uuM(OtK4Oo4&h=(y?#gllREGrpasz)0O`kNUUK^$T^T zC=5|I7W{hmIi!`s5SdA=?2VpFp2`&Q1oYZ{ctmb_wG*oiwfzDz%<`>-4Lat#Csy{P zOj3WoM8W!efqHTPXHN|0aXV6BHBkFz)UG@r^ry+SEI^JQp}OIg7Zyc7NxVxy3`lQQ)%Sczl{?gitsRo&$1jXgo}NvASNMfv_0rZ{TsYqK4;>1RZ< zKxa;1j*Nw@qFcI_NlNB>!cFz)jyB<6tpwfpop~MD?-cO-p*heJ?zi-?gwmeR<6hs7 z@O#tx(soB)483xe9;KeW84})gyAS-d7*aJqRN)Qu7AyPsK^lh1Q#U$z$rtO<|xlxNf#s%hUQhA+`qC*4ZmTrsr_vcieW_JpLrlFs#1;QarzD zZ>TsI9*^DDPPTdWwJ^ft)IW4q=5Opv8C-#Qqz$epS9aG>xb^w&sz8DD-aTF^GC&xd zrP8J)ra#%`c z0N>*ntY0Il*L8P9%^!qoa6FvWQ2$qlAZ^FY?dafFdcNN@vb>)W7OypppkJCq_cPEB1gNFkGyKh}a4hvD>_#3xC{v+C0WGSzEc@P%ZBS z;B;rDDr(YP^u9H;S7%W8?+NF-7PZ09C#UGCUa9}886826d=4`vgsP4NM<*>RgVCy; z+CaMqn-<_tat?I*os%${t#NK~rolH~1!AXPvz)Git|G9`J~+nql;pt_#=LKRgASU`WtP#~NGuAAknmUE^kL*3vJ)_H#R{Ou{| zt;A+C5z}1`Umk3yF}}WVutV_lO!Y0)#!okt(i&|CPbDrl1Qf0GZq!?Rz#k8#2$vyN*-~XaXfV7#Np&|R&us; zc6E-TqO3)|`pJ0(xc$;8VZ6!jDiqJ@tcd>J7R)V*$!MgjJrKjUTp?~Vp0t4!lKt-c z_;@XJlzlMy?SKOg@x~FF=!Y`5MVmZ<-gMj!gDS|bfZ$}#=Oo`$?a6F|97rlmDymIB zX{eEX2AtP?DETxB$2mezFVRs$v~C(A3d~}HKM%mVu%$SDzA_dI?!}6FN7I4x{0-i| zDV86A*vH@&pAZoF8v-mRWyE7`LRT}FG{p&QrVmhmGTBP%4P`$FF~Rxn)8kD7=sm*t zkVS7RRk=1j&X@9FxZgDSIxc`%rFH?OCw$^Y9O`eB!uG26BupDy5UqvDCOX|_(^T(n zgnP6=UW-GaZTC9L6EtaouG$BIXo6!Y%lMF1?>H?V!cdI=ob#sh?z?kc2#ZrYddVJ~ z^J&o^T-|p@2(4zSltU?}kBc04rScuA`+tSKa#$ez7WeEGGg8&-h*dwgaR? z)R4U3iFT&Z_{PpcI_9EGr0;0Q%;}fFgylf=HlwglOougEs4MBY*)1>M-4?H z63M6ZM|zk{2a{$yrVWiVPVomQSrC{6aIT_s$3Z$lnWoH8)=)Hl!gKkG&b$DorV92t z|8XPJ^@1VT5m7KCPPPNo>{rLC^VA<`V9u!L)!%TUm1eVSj1RRH`t@+Vd%us;5{VS2 zkVR_F3LoJd*VMTbv3d>6i6ADQuw`a(<$#!!IrUAj_z77pwGv-n-OSP?%wF`58B)9?c`f8 ze$bi#sRdt}u#;%8J6BEN=Dg@H-OT-fJsSyVJus(QmfOzScFQK^qWz-ka^w&KXm)=S zL~fgV675J`7F{vq1!-4+j^gXk$gP0hzJzTe8@9-3`m$%%G^Gw^5SJq-GU+hfS-)U; z`qyp11h5*0s-V}6$UPi^>~F7hD*cyAG9{xg|6{I+rhme6*cwH;WCMYfdxcB;n56@Y4IC4wAXVSGbd&xJv;yqbOX%ebTjbjQpi30juan zYZ|)o8|!+TPwq%X$ZwCcJM0aKmkj{TE#du-faSu~l8)7mqweLNOUMQRBB3A^bmOHz z0?=s$-8c#^V3lPo-Tp%Ge;O^-Wo`9AgG1jDvUUQk54KH!Xn9808BR{7sP^_CW|5cJ z60#{KgpCB8?O&idr6?mZJigLK`tXnDJMH-N7sD#__na^JMp;w;Vyu`dAp~NcUN_9 zK3{8S)}O>eV6fZ@>O)!6U_`iF=K3sv;RKAnLxB6iyq+p?5M}=nEm9z=el|-H1fYtR zM5@Jj0s+spoktDDLhE9XYY*QvU7ML^C>a`p%oBq~(L$>hXDpfNknNr}QT$JW++Uk} z*ihPV0fpx=3Qs7~v@T1V1GgxLlnYwK5kp>sF!-0k2w4&3wZ9e>Y^+zr2BDYC2VR49 zR)iBxI*#rIidaqJ?;I%Nxn|ytK2a5;aa&>=10kvB;_lu9lD66(NH@202&r)?!69 zLZ&`TZtjxzS76*-iUvAcUG&a|D4s%(Sm=`?10|J&Mjqf>EMo6?!YkjIzGwa9F&Ds0 zR2uy{jQP+PQr!i@Dw^hXE^QFD>Tt;zcN4%z1n z?w2QOKDwmpsQ&#)Rzc%wUv5T4c(}n(R2TaLgxIgGI&L@-mDywTL}QYcAte$>yLHmW zpD;8LY-d1340p0PEuFZZF|23>M;j_=t7aRNLL<;LR-n)9gVeu9-su6Q^ttb4I@25- zn2s0vX{j>}0a;(+ILT-ZGUo!$mL?fp7g1y00)rfO&HNl4I2>b1Da{;fl#49IGLeR| z|J3rr^2(CUst^MZjPnpWjJ?pE;kImAkM2D7uJ&F-zThMr>x1O!+LKd;Vg>KX54Z#K zDMghStPv)~ChQR~{1p)z-{(yJi4)zS3(6ICO4Ohn$XXYLPdyy%kVm@a8E37uEfKX5y~|OzOJ%tk+tb)!yaDyhU*V3Jj_qhE-RE}B z&M6!M*Kl(`#0HzgQV@MQo@_`G_;EK|hoEO4(S&BQhFYVnCD5m<(1TNQc;S z0@|C~XWJ{QWgJbpfyU9%ymYvo?XiyS!g5i>RUG3>Td+nB&Q@6>CUsEq4|%3|m!Y&s zbpzQq{i670H8-#{Azt~9ZIN=AW-9=KaUWvs1$zy4-g1sF99?ki1>;T|fEVq#vkIZJ zvN*!p`WA^ZmKdn>KYPp(s9+uN!Op+|y9-U=S8k5C5L9((zrV8P;T_B1#;mRua+-1N zw4@K3>xVp)dIm~v-p5ND8DY+E-btR~r8OG6b5C2M(p4D%{~2zdN@!t;<1zB@7K|?8 zgyhGHXnabbG=eX|FjbYPW4o~nMBw@ANF7^AbnG`vUTb+E`X!qYf8$trA|PCoXQJ^e zK;_;=g?uz!niKSP}ZXPQoGR|8)QhvIg}PE1$_9Y-BEIGuN0ok(4sch@A1a0z$$ z2)L_XVDr}Ddkd5j_$3Ns3oK@yVLk;^`oUVq))n&iCtC#NvKeyz8Vr@)lwVQs+mH+C z4GH)Pp$lPnH~b;ugVjRdO_fm3@WMJOExe2ItNM zk3;CBrvjx!{#kZYS<;Xl%(HMOU&kMojT7#cm&=9iWyxi1v>VmZI7EBmxh?3Z<{0Bx zPA2B9-_gSP)Y;PY9f_Rr?qhU*89YHA)$<34%;?LHa6+K}TKf8UWS(kShe0iqHHMYZ zM(G4I@IXldca~$*-ARji2tIQb^z>8W^pkvheYasW)6bw0zr}3pWu_x+k`Kt=;>Vnh z4fwF?zpj4ACVtuxPao9oU7<;H*TZhq8U3aw33NUhb8iI~TL8`A7qDt6{1PYeqeojB z;fs1>jkEou*wlfJht4E~=~ztUy%9pcA@DvEA66`Z>sXAWf@JAT&gm=PNPf9#zWM0P z>-=!hX}*Kd=cjR*U&l)MguV$YB{qT}X$06P$P|W|GB5Kzim{8!P%)KE)mabCuy=f6 z>VXe+0%&PHl<=QyP=(mR?Ut&RrZB_(2x(2Sd=HLYW!Z+?@g$h(SId1GTFDw_&1$ux z7`0C%!8H&Hc_HSL?Ygh=IvmYYY{DU=wDXbCwqQu9VylU)(VP|C7f~ZZ&WrcY%+;+- ze6p?F4=HJ;yok{W+wjjEVV(a%WAFr`jA#FWvZ6J^HiJF?99pw<1K>I3zVc9)uft$; zYyxg+ZTeyoY87tGmUSHfc$TqlIuCt3p zW-!KNJ>WP&X6P1sn56BgS22y^WP;~gEu z_(E!!DVb(u7Qw%Li2M(b_p{-EIcX_M>DolAUmtET3r5G|aw!yr1$G}xIf2`_H#hQd zLQGS2L;3#?kqgo<61><(Yd4oM+oj<4n}HG!fdOA3X2s*hO?Bt?Jn@E*ONmFGo#tCi zkF-}T022#0K1DqF~`UeKQGFk}m;8zhl?#7U>c{{R$hNG<5ZpoVnXYZt5d5UW^#mwXI9 zu@kRvYHkC7nGf1Oz-*RB=Ilh!T37~Y*RL9K2X6q*9MKIL^iLv3;5<9vhpv;_@{ zsN{jV#ioqUN%D9GXnYHBOJ^JsgY^BaI4SX~rnjcj<{FmWew+kFt+jCS&9)kBd1zvr z(6J3ujw%HZF@l|sT)7x1vK$R^n#hZyrl-G2ti{8!duxjUFr2kJ)C%Nl61hbOqlO-* zHe`pW$pz`y#66u1Y9per9r)G4e7!~1CWU3rTLlCA{j-5~F_zX?8ve1gvF?@6;!L_| z{|Bhs3B!ILme)i*O0o@kwFXAl1t{A)DL_{o1wmfjq1ukRcCeS-B)mAz^V&0>n|iBn z4_RY=!lWR5lutPI{8xI7y+i@iFoWf=7K7aiBb8px4`0|*?n6aQC5wKn!OoA%UPO^hak?3+%Q?3`SsZaDq2Q0f*j3seSZ|X<1y!D=L2nbF=Os> zD(;pBE+OrY)Z>2Z;3I!W)Q=)#qt8KsAnSwmRE#{?;7;Qzy@pkf2DoS{`xNLh@EQu;W3B8h z!)PsKsUaXx2%oXq?pua_5i=*-yy8`O)2&sa{pkX1#WwGX9Qz&3{z@wML zKi%5e5f8PWi80G)f_|~yAORbKg(4dIrkbshtrxk2@BB;-yM%M%A6p=hBNpdGIk_4} z>h^LsDD{yzSk|JO>?Pl-%hk>5X~M40)VG-E z3Na0)i|(h`@}lcD zz&#B9r#kC>j(ZvKU6hLuCU%shNlRv}3*KjzCsq6Umcgo-jK;=={{MWAH{K{;b_{eS zu+Y`?C23zyH)IW7$Tj>Z(|RgMdLuHeS+m9xTdKx1pBARxY~x})$1H99azmUyqaHBJ z11A&<=TVgc18Wb+w-f?0 z-!qY53C<(ohdItI@jE!Zimjz>C;^xgK$2EmsmJ8~>c9()hGcAlK{12c%1>tOnWLDq zlq-r1U2ac)Pay^yl_Z33_B6nITLaWQk<^iNElBs4)Pm@ph#>p~DDuYKll3;$QjmE= z>#Y;nDMFOq03cQ z*V(g*V9-dz8tQ@@nB=?YyDDn-ho zVQQm@IyN-7L4i8Rn<|>hU2Q!fKR3pMz*d9 zYKt)R-*;t)Tdc%DsVVM72oC3whw~#jl=rm8Bs&ViWHXx1JqBm=^7@|<+&@f~ z_Jy&S29r$Q4SyJ{pYED0mx8Q}^4L3Wfr+D#cH2@8-&m$w&y#g4f*x~&nM{A$0@%HT zx5-0O&=W8>2Hs+yyae4gGbq0y=A^zrvV&?Uwd)Bmy}Gl9v!<(^-*v`Sgl4Zh7UT)y zbVmp4sn_`^10$)&&&*lqM*>J#m9fR!Rw}2snI8f}O!lVsRL;Z&&O}>w`5)orD}w0; zku(fLhwKT+T|;U769)D?dPGgqn_uE<+KYv6v}cMZ9`n$1$Y_5Y&Dm6Ho}TG31?y&% zC|FY$h_?oPR(pDbA(-e_m@YC1qdA+!U?P~ah+pof0A2-*i@ceOyTZXH@X)pyoaD4u zLv(s>|6Z-`C<5ub72Tm24iqb_RYQ2IUf3cgd47bDJL8AleW6DyRB{uqX8rU;Bjoe)pSF_Q&hkxx8H;en1r+U2Tslr$ok)O&rFo=nUOtSPi4H- zO>xZh0=16h#F>~OHWGu~Obm7_;3;;2QcL(87^qt_!cL!9Qa4zd#g**D{GK>EI~jhE{L3zU_H1n-n5gURx^P+WgshiS%u{QhK|JX<+IlY(`ho7v=JhQLi4l1lIh&6yO_j(}`e z+f0SxkQ%HT_a?xb&4XE8ZQg|JvyVwLXOMnIC{=LMe8(wVU|&RPdp#(4w<@hkf8Rw! z$?M1oXlOlU6H0Efb1=$_*VA8InqB^2{aGMWOka|Znhg?N@2p2bluiXpF&xjR6Sn2C zB{oMYu8yOm4?kudrX6D9f{whF{_jKa5S3tVPISxN$pf6D`s^7;94f-Ff3oWQd|>KDAx+#>vCWQgAM#N(35ga4qarI{rbX^&J)bQn>rtq zzYMx(9gTQ~ZQ75IdE$t`U5_x4N`Rj%qy@?_xN0;FTs+KtZD6AbQ(7_bw*z;1E%=Bw zZa?O@Zy*FFan;y}&M04ZXX$ktT)cODK?`9fOEzj5AFk&?i8C zF=9>48<~qM<6$@ZxRz4y|HW)pTwI0J5PhDG6I;R*n3e6O8bF`s;M;1-T*nVMcy7Y+ zKK5kv=4A|y4Nq}(eQaV|8uMhz-!8^WUDM1@4OJqNan$Q36jZm5kk=Yc&3_$wWZ@(< z&Y}FE&89pUK)yjrnF$73hYjZlTiQ=JK{N)SoBSsTeBNc}2vW;BDmiMw?6=Yh_`Vns zCLs09B38K;rvENPMHoGojgG4hkn<3Q{R}fWU%-$DF?&=Dt#rB?BRY;I0nbrCdr?ki2DT*?DDUz{(caQ<7{q7^Lm7dcR?pMXCo8#j!~fb?I^Xs z;0BZIIhd#?oM5$4K@#!LB$E`F${oB$hXlgD^ai;xpBe*>uR%JmITTn|__~3N;YuS1 zW8}=XbhM!Ych*N04ED_MJoI$;Q@{?Ot^UrSvovO4(N{zT%s zx9rHl?O2Rg$SH>~uOvT1R2AI3^U~RGuxp53?F!@EXhD3pFy;4a+bFEoLzJ!RM%PL_ z5HH0q!^7x$iZ5l%p^!yY%_A82xD~2MC^)h;PMNE`V0cRqC-Qf-i(>@K?GkgWBDIyr z4JAs3(z^WXIq8k#4%h~h{TB2XDs6!`3^Qdh6-7#O178wMEwp++;A%8!hE{%Iu>Zo` z33K=$ew4`bF9uZ~Fdxw+wIGT~mUs3n5w5CF=u@NXxPqed)>7PBMvs~Fu@0u|m}gyt z`#}Ufg@%^F7D&{y2*h<9n}0nT$*#DDHqk}CWyVD%xdRmAI{8A7d`~cq+TUAoPt`t6 zq#>5dXt67J;k@?pEUboX2_0EhgIHM8XvVJ+^t_LwGe|8;Q*I)U-5FEB2CnpZuJsLK z54q_IJs{BG%)1a#+>;DLdd_B^-&qWaqMA;L^dxLGmT^?eoa?}*r`X6JP|{vHjm4>I z9vYSYG>Ll{-w;B4u@*37s(Tyrjsl1{xY509YAtUWn){8&n=xJ=RH2AIkN4(g_HjIj zQHl=L_ksfy(_x&hde+9YVrQ)NY{zXEZTIBA&*;l-v<2Fgo3%O(MhB7NAyMDX)$G?-1MJ-SCHOplunVwTW2^CTt-&eDedZ5Ulp z@Q?@4PA^zm)Ax*HFv$ViFXX3#u&*d`eeHCdF?+XVG(ne`Y;7kL*A$n*3hXG}$izxP@tigh_d{+XR9=gs@YU-JL3C~^=N4CM7^BI6w-sFB8;jRkGKUAqZDqoU`($fidGZD%3Kur zEl_l)_(-=zuvVMA2)`=hCE8ZXg0XuD6=)H8{bP)ddgyt|#_bMx2($! zk<7eECPluRYj+t4CI);yAU*Q0wJg&%l9)#D42CU-KK^$QRL})Fg$R<7MfixhDgIrN zXd-b>PISC*)W@4MoY@g)ov)b{QJGO=MPUMlks~_iE+W$)x5iO$kgdM}=Ehkd+4NQ3 z*w+H#4(=U|?jA^4=M;N}N=vD5TJ5)n>0*XLfWI<)q9|+0_yoqly)FR2?8U-#1;bXj zr6e>;ZA;_-((4Q8-*!^aZd20!u@r_8tH*xWgXx&UC%v8K`YN2*pRkG!rY^L#bztbx zH>B66KsFp>B-~TmE7;p;+HFzPy31oK;>B4_gnc`l;&~*vKe6oCVEa7#0d`3vhMWW##&PN-F&;_Vz02Uzyw|xVkiIsN6A19%;nclibW}F@ z#rL909Mr;278LDAV#fr z>6V3#Y($ug6eIoRPG;~O)o1YC*QW>wcWQM#JetI82PQlC!7p!>qVNOV@%(O}X8mn1 zz?d#S^kN{U>T;N%{za_lfo=M4rd6KRCo_EM4x)Sm)XjokE_(W(EuEnRXW4Gs%yM%-BQNS8>8(>n;7R=vH^T+C)kiSh zIYDcqv0`jRq|4>l;c&3dnm9XfyWT)q%EF-3s|={L!kcVE=WpRn6rX-gsMLbHa1E1J znlc;cGK^(LydOVWeAXKDY+Z<=rXX*R(r>F-FqB%Z!;HAym1a{>jdfCa7GhZt}Qj*Y2uR&JkCiWk;F7}|teGD$O^HjH(Qw71tifeXn#9usp5a0U|Y zaD+I*vBno>P?Jy+1R?-JPpZEZ2*_@)nCRWQ4^#|}IT{db`rWlwY4 z0pfK%ZP{l_dcXH#;RAJtis`gcLDO{1A1=DPaK#;%1FPhWcCyuC5`t^$n;7jqG2 z=D7UCdfIS@js_mgqno(u`xC!Ns6Nji+T;KfY%|3J0#BQdfmO!9;vV4f6C#w8(^k+{ znzXQha4EzYwm_>I!2s9NG=Acq5Y6czYNV+;Vuy*= z1PBm6+(}A!DC)mHC;f3K58M$+$_8X^ zG}_~5C|43xeWW=LO|md=I-%>UV^VBu?gc5C4yC5!+Y?#s6?#HSn-FRor1gw72KcvG z79duggt2{Y%}i{ev>wKGbAoH>L#ht3r9|M3%0Z$jiAg6*=(Tq1xtmP(PfQt8Ar1d>~NO2`ycjaaQMLtZEnh#x2g1|e>%jJ-7OFc#Tmt9W6o+XMpJz4NAWvL zg!iqh2s}dqTfi`u)HIfqpdGhjefo=GnJSobBedvVsPWUp6U7jLe?0--%-#rZb~A?=U7hXvCS0dH;kv4TQkXLK7s;rm*)l(E+MZ4@%F&SRs_>r{cEa z(cP)!%Sw{DZbHM_8)bYP9mv9Wp|XA2mnDoo%^hp3E#I+BfVJ3;J?;)eH}kRK7Nt~_ zV!*RaR#Ee+6I5)+e3(JR52h*$6_HxnpbZTK+2BzqRs6iYIs!*maAj`>F%CkE9;-`9 z`)C_3zngmUhA_)3!xv&EcucVZ%zqo=oCaOB8PCBku*%QQ3Mi*7fMm(^iDR3;eJ$k3dBGt{uy}t*Wm5n;@PD|7>%RrUC=F%C1?&4fHR4Vw(JFT zU(eL#W89bI3nDY?R+td%M!9&(hRi_snoQ|QBnm3bF;m%350Rz0_U<7<&$X4?4Fjj8 zP(zvd5#ldEyHBbTOip^Q!{P*x>6WQ2U15DSF6%zu z1wY74_f45H^B5};oGrjds7>xQ*sFwoB#E>w_| zeJy_Bq2y1N0?W<;3NkTGLM6D?77kPlS3U~x%!oHL78xRa7WFLKMxfXY#t0c?Kll-8 zw+%>Oq&x#z@*p_$FA~7T@b}h0jvNBrvmVRZ9kh!)b`R>sm-g{Uk0$_OK}6RaYGanj z1ac@_C?ijC2bN$HNr0aC3TtO776UQXDco5SQn(G162~(EZ8wz99Vnmdu9$9&!>L2E zst2RszI82w?YTl2Aqu9aG9KEl?ysqJI}m~%A*ttOAYwH(ny(NU*MYQdF`cp~^j>4g zt>I|vYazFub2AlTv9zLF5`Epp^vBY~XVzz>Yl%_DQvS~H`^hkF-*ATanJnhc42xKS zkp3rou!>V(IM8O(&Rw=tw~k~se+2Yz56;6UBvFwRL??XVlM1HB-SU? z(2i8lH5iy5Iz{3!95-+_mQM!um;E{gnOQhS{ZhJJJF_`GxBtkp(0UOLMg!U|w~qr# zEKvXQG-N5-gc}PR%9XzgfDHGEHcxSg`o>ADF7)LM{k&$6L=9%G^q&=oDHe) z5C@9S)(X6L*p^AL!|XK0kUEZbGm`$ouYlsN*bBNZdhReiZl^aFUe?Sy7dfAR7Zg1Dndins{^6m!wXlYVr-R2oUUc4algnC%_%QKbl?2jCk z;2EAfN07;}@DQ030Ljvx{h+nXQYp@Y*;Ed9w^P03-UigxqHiXoCmHsnE zGo?%8Nif00YOgb{)uUDg-X1`|$x5v*C#Dg?vgwx;q*KZdFer+dx&gL}$4rc^#nhk@ zj0zZm464a3Fl+5__Qb?<+TEPz3VrQa#*Up?x1bI|L^w`($ito7hv;4gtC4%SB^Pr9 zP1Q4NVfMVLIQ@N=eTYN zQ9%lmvhm+g%$yC-up20~R4Fn{r|1Io*<6Jzk$xJGv(}SxQD*@LJO1P<;co73;Cbtn zqQi8bbbE67apr2w!8BT@vq2o^@@9cGx&||t2e-#L_i2yHbhe(rbK&FrS$qIfn6B+K zfUr%X>Sf~mdXWp#ATaMT9i$emNZYe%YC-#e*s?im>fkmk}|EIX6x?xfZKkrv-E)d)_`lQKnHK4>(#>VEdmxf!b z2(Q)|ATh>116S~NXo&p)iFSy?8<~e`bmaD9^Kvsbr!_HxL6p4FIEaS0X3{}s1)YYW zosVH_FmqdvVKb0?Vmjk+X4=evu7xv63=>ZP!wi*++>6`P1cq@MdA2yqFj_r`B^0_I z@P@-67Q{n}wsFs8Brh}&%g$Qn0o}C)^dhdI8Mhgt{iFD;OR_YEFu?3A7O>1}QRw(R z^hR0S`GLm`!0>$tVrz`ci{O5!1Yah0v2RFQ>|?mVD@Gv25bYc0y~8gWfiR|Fo+Rbb*S1C?C^|9>_`IW;Nf-Jdt-djqTE_iG2Sl8~M2lj_J zT?Sp@V|rST>{QR7jQ15l1P!pU@?YtG8@{KKuX<6NUl>x;m_$37LNTONNfb(LG| zS*=vOXEGi5bfSG5kXcWu{s-zBPN+nxs3DkCnECEI%QAnsI|KW_#Z6O)H$I1`9K`^( z&fJ!}KT)5Y*GbeC;@D3b-04jH%UZTy#sYFmOu8*y4bM*YeI7gZh+^EXh!-_CppnU%;9 z&0!GoF@0%P)5Xjl#GA)rg4yam&c^jS8<)U8W#AC@!!EtXeA8cl5Z`P@!adc+!8$y8 zV-&Q;4xj&8`n;ycVLUZeO!OG7 zs%-N2LFan{i&F>_u@{A^sm_&I0LATyx=qLRn2)WaxtMnYFL|D!?&8@Lt6*XCk#4I& zUp|CcroS*{pec>=66pCVmco_TdMTZvy=C>@r%Z%BPutb=#TnfM~ zh8ft|w%P#w9_xET1^BbQde>jY*Nh%@IKtT>;vWndj}F&8V3L{HoPPS#eVq1s;F<9Z z7F>jcdLP4o30!yOm}A$)=3sWlVCcq2av|*Uy*b$jFh^yw7qhoy(^^M&ZYSD)9nY0` zPTO!!_clioDoYbNB=0o1!_jI`Q6TDg_n6)>z>$Ui|;|0X|#s?MlH5gv`>v6~4DNBEjis~Hh_W1*@$*uTOB zvJay0f&GQOK79UYKGZp~Y4w;itTB7SzyOcyDoLVzFk4@630AwlWFwjg%d7!fg#~{J zhQHPBY;?#CF<4HeGuAtac-DtDyMR&lcVsg8Xd1=B5CQwlk8w>WSiU3FaLrN{cWN+w zzyQ(;H$Zv?D8Kno7z%=0GSaz~Cvz~2F(YsA<26E{{{#BAHA=%CrnbBAo~fw6T_MpP zx#uw#L^ufUc=O`!O2%p@)eYCT<*a^Ir=K>v01@~p^rSKP3x_kI{HCQ2{pU1r${swG zS9$1bS7ytLQ`?HuDW3n(Tp0+lyq!J0E1+s2kSZ7zERQ~6wFTzYzT9$qU?=l2u%j%$ z;6c0t|2QnLtIeFfDC^l=g%drf{>(jpmLia6p=VCe3hO7D>EVCD$>MFsIecscQ zjoLUe7X!4yb%S6v+yH$zb4N`L09q^9nnm05yQLWwZzMJ11kd37nLmSB6F-(HK$T#+XDOU5Z>64+Dz;0rpti(Cn%0qH8 zQJ&h;kYDBDv+*?I^X>k#4BwDRw`&ZI3F48iok)hvXNcfy967x)_FIr=oAdnHW$;)p z@sY+LDmDTA&0`SbV|R8>2DH&iV7>9!;bItOgvOr|u4Cao>~^u}LjRg8aT71c*ZG=J z3N5W6;OiDjS*l4t`$j(ib1eCsi3rEfc(le)_{v8#_FiDuNLMikvu{|%VtjTU08~ac zSwVyKf&5y?etr)RXKqH!REI(w2;H@re*F%}DO|e1nF;|3?_rjHMcu2IjI(PyW}_ou zi2|g#ljJ;jrTqhyA0Xx5DA^HG2VkW*OaSXX;zT3^L=`4aw}8YNk3_TscH$9hy|_O6 zWs+kZQGlCF$H>N0G-@!yNTY(^#DtO?@~;lbcQG+)J9ohowx|+}ZEeYoIR$<6FqX8p z?n4yxXuy1VKc6O7aLAQ7h6RrFmtY+{PU`A~`4}EHj-Z6qtwiu5MA1O8c)MjC8 zQW#<1kX0}mx$TJgg*g@x@hOs8Q8wP{CJ!^su#Bhq%RsSO00;aR zbbu&S$+%B`;O@JLl#+`%M7^MJs(@DRJE8&417V%lLI*!4_!R_DK1?iIBClBzwr(%6 z>_0s=_OKXwnbwfy(ynmb1RLh3Q&ezmx8fcfiG;q237voQ@U4|JG=BJw?L3MoQh%IB zX`Vh%iM@CLjq)+(TZceYCIc0>^C*vpa&@Ji(hBaPKlj`Svf61pec&EX%yDxS&yp$` z=Gw~M6bA{;$vqXWH;Wfc5$4(^aW6?$i}WD?suO^ zT^i)iW9G-3xceG7I^y8HhI=;~vSLH-yne2U^cA`3vV=4KxaSHk%)ej)D-n(wM#N?{ zW7OC`ABXFhydl%w&*M1ENCc`33x5P;-&yk`i)t&tNRZCcPZ^?3EN<+kCBDQ_P|9db(&kJs zgox=#O0xtA-X3f)qmV~u`WEmMqfNNF4^u%elSFzXR9VZSzO(m;R1uXqm;kWBBlELq2yL^635X zRi8U9h5dK@>gSF}e>iTmeCFrJe>m>_-0{Q@$Gd;-c*=+4b3S)G^~3QKpF6(m!|{JV zcl_Fi<7KR$`TeEv|2}`K&mE8caD2k&j>msEzTKHt^P9gqHS z+^Bx$_ly5<-21uXi64%4=eYlUJ$zrkQvN%hUMI!hi*-MVzkiS=LVpZq`fo@<&-Ur- zhS@)TJu1hiuhVjV`ucIM2>&NiQe{7V z9d7#c^#ebDvFoFMu)_T5>mWFyD5mJoqe)I;nvPVhzK6)+Xj!MUS@7^QZ|GbX*pV#jHd0qE^ zUVri5>s;yY*#E!3NPj&p_vUXs#!iV^);Y$kS)_vv2J}vD-%XN+@;}wOcTV11Y>u&H zM&Hz`?fXlS4{P`6+`GLLIj=#_&fU4Rb-Q*%qk4AlnAEwg6gj6sv$_=$q{#YR zdbaNdKe|DL*Sl4`Z-j+9lQO;S6ibvJ0&t4C6jB+aPQ zzh{qL41|ep*g2_vZ%JC*pnX#NcF7ex_mZUK3RN1kPfqUKy(0(QwJKElf*&iD5#L#% zN6!J0)TctP_HB~eWB)JLwnrb1-LBRx{p}jot!&ENQ2*P?J$il9cb;)`-+2*Z7XKeP Ce!|cI delta 313732 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�tz2*I({&`EMNv3sDmoP_?fJ;&Q;{k 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

    OwO; zlC=UEL?2rBd1ZS1=l`ZIWIuRm^-rLdH8?1o(J^RS!nHLfg?al z6-D+*!+!zz4?_n4^YQ3BY#!WjRfP2{Vy$`6#JjfkWnE_23nI>lxRN45%{ag$B2rkC z#;F&S�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 From 8583135ad43136959b47ef689b2694ed865431c8 Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Thu, 17 Nov 2022 11:25:46 +1100 Subject: [PATCH 6/9] Update tutor.html --- Tutorial/tutor.html | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Tutorial/tutor.html b/Tutorial/tutor.html index 53b6186..b94ead4 100644 --- a/Tutorial/tutor.html +++ b/Tutorial/tutor.html @@ -1093,14 +1093,15 @@

    #end file ; -------------------------------------------------------- !RunCMDLine -;"C:\Users\My Name\Desktop\My Project\convert.bat" "C:\Documents and Settings\My Name\Desktop\My Project\file01.png" true +;"C:\Users\My Name\Desktop\My Project\convert.bat" "C:\Documents and Settings\My Name\Desktop\My Art\file01.png" true Tips: 0) Path and command must be full qualified and in quotes on the next line, with the first character skipped -1) Execution directory is where the excutable is launched from (where your ts.exe is, ie C:\ts\) not your project folder -2) If you use a batch file, the first command should be a cd command into your project folder, put pause to debug it et +1) Execution directory is where the excitable is launched from (where your ts.exe is, ie C:\ts\) not your project folder +2) If you use a batch file, the first command should be a cd command into your project folder, put pause to debug it etc 3) if the cmd box flashes and does nothing, it's most likely your paths are wrong, test first on the command line. + From d7425b80ef3e91b816f4a4f24fc37eb730dc22bc Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Thu, 17 Nov 2022 16:24:13 +1100 Subject: [PATCH 7/9] RunCMDLine wait set to TRUE --- Main.pas | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Main.pas b/Main.pas index 30a494c..0e56e43 100644 --- a/Main.pas +++ b/Main.pas @@ -13729,7 +13729,7 @@ procedure StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: bo if (RunCMDLine <> '') AND (ErrMsg = '') then begin // StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); - StartProcess('cmd.exe', '/C ' + RunCMDLine, TRUE, FALSE); // execute, show window and wait? + StartProcess('cmd.exe', '/C ' + RunCMDLine, TRUE, TRUE); // execute, show window and wait? end; From edf3b5e873125bb94058f45d1383d91f27fa41c5 Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Tue, 22 Nov 2022 22:26:14 +1100 Subject: [PATCH 8/9] no RunCMDLine on F10 and better docs no RunCMDLine on F10 and better docs --- Main.pas | 29 +- Tutorial/drawing.html | 270 +++++++++++++++ Tutorial/tutor.html | 739 +++++++++++++++++++++++++++++++++++++++++- ts.exe | Bin 1067520 -> 1067520 bytes ts.tsc | 1 + 5 files changed, 1024 insertions(+), 15 deletions(-) create mode 100644 Tutorial/drawing.html diff --git a/Main.pas b/Main.pas index 0e56e43..0d83ea3 100644 --- a/Main.pas +++ b/Main.pas @@ -13724,14 +13724,6 @@ procedure StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: bo // generate the code ErrMsg := RunCode; - - // run cmd line if not empty and no errors - if (RunCMDLine <> '') AND (ErrMsg = '') then - begin - // StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); - StartProcess('cmd.exe', '/C ' + RunCMDLine, TRUE, TRUE); // execute, show window and wait? - end; - for itab := 0 to Tab.Tabs.Count - 1 do with TileTab[itab].tbr do @@ -13741,17 +13733,26 @@ procedure StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: bo end; // CMDLINE_OP - if ReadParamCMD <> 'F10' then + if ReadParamCMD <> 'F10' then begin - if ErrMsg <> '' then + + + // run cmd line if not empty and no errors + if (RunCMDLine <> '') AND (ErrMsg = '') then + begin + // StartProcess(ExeName: string; CmdLineArgs: string = ''; ShowWindow: boolean = True; WaitForFinish: boolean = False); + StartProcess('cmd.exe', '/C ' + RunCMDLine, TRUE, TRUE); // execute, show window and wait? + end; + + if ErrMsg <> '' then ShowMessage (ErrMsg) - else - begin + else + begin with ProgressBar do Position := Max; ShowMessage ('Code generated successfully'); - end; - end; + end; + end; // CMDLINE_OP // clean up and release memory diff --git a/Tutorial/drawing.html b/Tutorial/drawing.html new file mode 100644 index 0000000..478913a --- /dev/null +++ b/Tutorial/drawing.html @@ -0,0 +1,270 @@ + + +Tile Studio Drawing Tutorials + + + +
    +
    The Wayback Machine - https://web.archive.org/web/20220829054234/http://tilestudio.sourceforge.net/drawing.html
    +
    +
    + + +
    +
    +

    +
    + +

    TILE STUDIO DRAWING TUTORIAL

    +     +by Mike Wiering, Wiering Software +

    + + +
    +

    + +

    Introduction

    + +
      + This page shows how to draw some simple objects step by step. This demonstrates some of the + special functions in Tile Studio, mainly functions that involve using the color pattern. + Of course, for a complete overview see the Tile Studio Tutorial. +
    + +

    Drawing a simple grass tile

    +     +
      + We will start with a simple example of a grass tile that could be used in any game seen from above (like some 2D RPG's). +

      +

      +

        +
      • Start Tile Studio.
        • +
      • In the palette on the right, left-click somewhere in the light green area.
        • +
      • Now click again, and again and you'll notice that the color pattern under the palette changes each time. Continue + until you see a nice shade of colors for your grass tile.
        • +

          + +

        +

      • Now we'll choose a set of colors from this pattern which will be used for the grass. Left-click the shade just left + from the center and drag two shades to the right, you'll see that the line above the center becomes an arrow.
        • +

          + +

        +

      • In the toolbox at the left, select the Filled Rectangle ( ) and + Smooth Random Fill ( ).
        • +
      • Finally, with the left mouse button, draw a rectangle over the entire canvas and that's all!
        • +

          + +

        +

      +
    + +

    Adding a path in the grass

    +     +
      + We will continue with the grass from the example above and add a path/road. This is just one vertical path, but + in the same way you could draw several different tiles that fit together to make any path in your game. +

      +

      +

        +
      • Make a copy of the grass you just made by pressing Ctrl + D (Duplicate Tile).
        • +
      • In the same way as you selected the green above, select a nice shade of brown in the palette and select the + three colors at the center in the color pattern.
        • +

          + +

        +

      • Now draw a rectangle in the grass where you want the path to be.
        • +

        +

        +

      • The edges of the path still need some work, we'll make them darker. In the toolbox at the left, select the + Darken tool ( ).
        • +
      • Now, draw a vertical rectangle (two pixels wide) over both edges of the path so they become darker.
        • +
      • Finally, repeat the previous step, but now make the rectangle four pixels wide.
        • +

          +   +

        +

      +
    + +

    Adding a tree in the grass

    +     +
      + Now we'll add a tree. Instead of looking at it from the top, we'll use an angle of about 45 degrees, so you can + see a bit of the trunc. +

      +

      +

        +
      • Again, make a copy of the grass by pressing Ctrl + D.
        • +
      • We'll start with the shadow. Make sure the Darken tool is still selected and now select the Filled + Ellipse tool ( ).
        • +
      • Now, draw an ellipse for the shadow and add a second smaller one as well (see the images below).
        • +

          +   +

        +

      • Now turn off the Darken tool and select a series of three shades of brown that you think are suitable + for the treetrunc and draw it as an ellipse (as below at the left).
        • +

          + +

        +

      • Now choose the two darkest colors in your color pattern, and from right to left, so that the arrow points to + the left
        • +

          + +

        +

      • Use this dark shade to draw the rest of the trunc, which is of course darker because of the shadow from the leaves.
        • +

          + +

        +

      • Now we need the green shades again. Press [ or ] repeatedly until you find the green (or choose a new + green shade from the palette). This time select a wide range (from left to right).
        • +

          + +

        +

      • In the toolbox at the left, move the circle in the Default Bounds box to a higher position (by holding + Shift down and clicking at the new position), this will make + the lighting come from above instead of from the front. Also, left-click once on the Line Width box, so that + the line becomes a little thicker.
        • +

          +   +

        +

      • Finally, draw the leaves as an ellipse and your tree is ready!
        • +

          + +

        +

      +
    + +

    Drawing a simple cloud

    +     +
      + Here is a very easy way to draw a cloud in Tile Studio. +

      +

      +

        +
      • Start a new tile.
        • +
      • In the palette on the right, choose a nice color blue for your cloud.
        • +
      • Now hold Shift down and choose white or very light blue. You'll notice that the pattern below the + palette becomes a gradient from blue to white with an arrow above it pointing to the right.
        • +

          + +

        +

      • Left-click the third shade of blue in the color pattern and drag the mouse pointer to the left, so that a new + arrow appears pointing to the left.
        • +
      • Again, hold Shift down and now select a dark blue/gray color in the palette. Again, notice that your + color pattern changes. Then select a range starting at the second shade and five shades wide.
        • +

          +   +

        +

      • In the toolbox at the left, hold Shift down and click to move the circle in the Default Bounds + box as in the image below and select the Filled Ellipse tool ( ). + Also check if the Line Width is set to 1 (if not, right-click in the Line Width box until the + line doesn't get any thinner).
        • +

          + +

        +

      • Now hold Shift down and draw a few ellipses to create the outside (darker) part of your cloud.
        • +

          + +

        +

      • Now select the lightest four shades of the color pattern (from left to right) and go over the higher parts of + your cloud (again holding Shift down), stay within the area of the cloud to preserve the outlines.
        • +

          + +

        +

      • Finally, you might want to change the background color to see how your cloud would look with a blue sky. + Select a color and use the Flood Fill tool ( )
        • +

          + +

        +

      +
    + +

    Drawing a heart

    +     +
      + Many games use hearts to indicate the health of the character you're playing with. In Tile Studio you can draw a heart + with ellipses. +

      +

      +

        +
      • Start a new tile (perhaps restart Tile Studio to make sure you are using the default settings).
        • +
      • In the palette, choose a color red and click repeatedly until you have a nice pattern to work with. Then select + an area in the color pattern from left to right.
        • +

          + +

        +

      • In the toolbox, select the Filled Ellipse. Now start with one circle, which will be the main part of the + heart. By adding a few more smaller circles/ellipses at the bottom (hold Shift down so they merge with the + existing ones), you can make a point at the bottom. Now add two ellipses at the top (this is probably the hardest + part, you can undo by pressing Ctrl + Z and try again (note that the coordinates are displayed at the bottom). +

          +     +

        +

      • You can still see that this heart was made from ellipses, the edges still need a bit of work. You can go on + drawing ellipses from the center to each side until it looks right. Sometimes it might be easier to edit those + remaining pixels by hand.
        • +

          + +

        +

      • Finally, select the brightest four colors in the color pattern and add two small ellipses at the top as a little + bit of reflexion and that's all!
        • +

          + +

        +

      +
    + +

    Try these yourself!

    +     +
      + You should be pretty familiar with using the color pattern by now. Below is a set of images I made for this + tutorial. Unfortunately, I didn't have time to describe them all, so you'll have to try those yourself. But here + are some small hints. +

      +

      +

        +
      • The Egg (Mario style) - First draw the gray ellipse in the back, then use the Add Colors tool to add + the small green ellipses everywhere and finally (still with the Add Colors tool, draw a white ellipse + in the middle.
        • +
      • The Grapes - This is done only with ellipses. Start with the outside and in the end add the ligher ellipses.
        • +
      • The Bananas - These were done with the Paint Brush tool, using a thick Line Width and a color pattern + of course.
        • +
      • The Apple - This was mostly done with the Add Colors tool.
        • +
      • The Rock - Start with Smooth Random Fill just like the grass, but with thicker line width for more noise. + Select color black and with the Darkening tool on, keep drawing thick lines around center until the + stone remains, surrounded by black. Then use the Flood Fill tool to get rid of the black and what remains + is the stone.
        • +
      • The Brown Wall Tile - Again, start with the Smooth Random Fill and Filled Rectangle tool to get + the noise. Then turn off the Smooth Random Fill and hold Ctrl down while drawing a rectangle from + the bottom right to top left (which will become a gradient). Finally, change the selection in the color pattern + so that the arrow points the other way and make a similar gradient fill the other way. +
        • +
      +

      + You can download the project file here: DrawingExamples.tsp. Have fun! +

    +
    +
    + + Return to Tile Studio Homepage
    +     +
    +
    +
    +
    +
    +

    + +

    diff --git a/Tutorial/tutor.html b/Tutorial/tutor.html index b94ead4..b9784ea 100644 --- a/Tutorial/tutor.html +++ b/Tutorial/tutor.html @@ -33,6 +33,7 @@

    TILE STUDIO TUTORIAL

    Contents

     + + + + + + + +
    + +
    +

    + +
    + + +

    TILE STUDIO

    +     +by Mike Wiering, Wiering Software +

    + + +
    + + +

    Introduction

    +     + + + +
      + Tile Studio is a complete development utility for graphics of tile-based games. + The application contains a bitmap editor for creating tiles and sprites and + a map editor for designing level maps. +

      + + Tile Studio can be used together with ANY programming language, since + the output is completely programmable! + You can program Tile Studio to output your maps, animation sequences, + bitmaps, palettes, etc. in any format and include the output directly + into your source code! + + +

    + +
    + tile editor +     + map editor +
    + + Tile Studio - tile editor (left) and map editor (right).
    + Click to enlarge images.     +     +
    + + + + + +

    Tutorial Video

    +     + +
      + This video gives an introduction to Tile Studio and a demonstration how graphics can be exported and used with HaxeFlixel. + +

      +

      + +
      + +
    + + +

    When to use Tile Studio

         @@ -88,6 +170,11 @@

    Contents

    + + + + + There is an auto-detect button that can often find the size of the tiles automatically once the transparent color has been set properly. You can set the transparent color by clicking anywhere in the bitmap. Hold shift down to @@ -214,6 +301,7 @@

    Contents

    Drawing Tools

      + Complete Tile Studio Drawing Tutorial.
      The drawing tools are displayed at the left. Here is a description of these drawing tools:

      @@ -727,7 +815,7 @@

      Contents

      BinFileByte - The current byte as an ASCII number
      BinFilePos - The position in the file (0, 1, 2, ...)
    -#list ListName [begin] [separator] [end] - Command to go through the list ListName
    +#list ListName [begin] [separator] [end] - Command to go through the list ListName. See July 27, 2008 below for examples.
      #list ListName [begin] [separator] [end] - You can use lists recursively
      Item - The current item of the list as a string (if recursive: ListNameItem0, 1, 2, ...)
      @@ -1127,6 +1215,655 @@

    + + + + +

    News

    +     + + +
      + + December 25, 2017 - Tile Studio II first release! +

      +

      +

      + + + February 21, 2017 - Tile Studio source code now on Github! +

      +

        + + The source code has now been moved to Github, now under the MIT license. + +
      +

      + + + September 26, 2012 - Another update +

      +

        + This is another quick update with some extra features and fixes: + +

        +

          + +
        • + There is now an opacity slider at the top, so you can set the opacity of most drawing tools (when drawing on a transparent area, the opacity is always 100%). +
          • + +
        • + Added a simple kind of onion skinning: right-click on a different tile at the bottom to see it vaguely through the current tile. +
          • + +
        • + Added Tile | Replace Color Under Cursor (Ctrl+R). +
          • + +
        • + Added View | Used Color Patterns (Ctrl+P), shows the patterns you've used before, you can select (left mouse button) or remove (right mouse button). +
          • + +
        • + Select next or previous clips in the map editor with Ctrl+Shift+Alt Left or Right. +
          • + +
        • + Added RGB Color Conversion Scripts (tile editor, bottom right). +
          • + +
        • + Quotes in .tsd files can now be "..." or '...' instead of only "...". +
          • + +
        • + Added Tile | Use As Alpha Channel (Shift+A). +
          • + +
        • + Added <Counter1>, <Counter2>, etc. (up to 99), automatically increment. +
          • + +
        • + Added option !StartWithEmptyTile for if you want the first tile in your tileset to be blank (use at the top of your .tsd file). +
          • + +
        • + Import Palette in the palette manager works correctly now. You can also set up a default palette by naming it DEFAULT.PAL (F8 to switch to palette). +
          • + +
        +

        + Download ts.zip (or just replace ts.exe). +
        + Tile Studio II is being planned now, if you have suggestions how to make the program better, please list them at + Tile Studio Forum - Open Discussion. + +

      +

      + + + + + July 27, 2008 - Quick update +

      +

        + This is a very early alpha version of 3.0, and it doesn't have many of the features that I planned + for 3.0, but you still might find it useful. +

        +

          +
        • + You can now type lists of anything you like (Ctrl+F10), + which you can then export using #list ... #end list. For example, you could make a list of + sounds for your game: [Sounds], JUMP, COIN, FINISH (each on a separate line). Then you could + export #list "Sounds" "\n" ",\n" "" and inside that you can use <Item> and <Index> + (also <ItemValue> if your list items are integer numbers), + for example: const SND_<Item> = "<Item>.WAV";. If you have multiple lists, + you can also add the name of the list as a prefix, for example <SoundsItem>. You can even + use the same list recursively, then add a number (0, 1, ...) at the end: <SoundsItem0>. + You can also use lists (with 0 or 1 item) for conditional compilation or as global constants. +
          • +
        • + Also, you go through a text file line-by-line (#readtextfile ... #end readtextfile) + or a binary file byte-by-byte (#readbinfile ... #end readbinfile) to export it in some way. + For text, you can use <TextFileLine> (<TextFileLineValue> in case it is a number) and + <LineNumber>. For binary files: <BinFileChar>, <BinFileByte> and + <BinFilePos>. +
          • +
        • + You can now use IF a THEN b ELSE c in numeric expressions! The result is + b if a is not zero, otherwise c (note that ELSE is always required). + Further keywords are NOT, EQUALS, ABOVE, BELOW, AND and OR (only works for numbers though, not for strings). + For example:
          const <MapIdentifier>: array[0..<MapHeight * MapHeight - 1>] of <IF (TileCount ABOVE 255) THEN 16 ELSE 8 : "UInt%d"> = ... +
          • +
        • + In edit mode, the coordinates of shapes you draw are now logged (at the bottom right). This is meant for + drawing animations, where you want to make slight changes per frame. On a new frame, you can press SHOW to + see where you drew each shape before. +
          • +
        • + Other changes include (limited) .PCX support, replace current tile sequence in map mode (Ctrl+Shift+F7), + new #sequenceframe ... #end sequenceframe (same as #sequencedata, but goes through each frame duration+1 times). +
          • +
        +

        + Download ts.zip (or just replace ts.exe), enjoy! + +

      +

      + + + December 1, 2006 - New BlitzMax example +

      +

        + I just made a complete new example of scrolling layers in BlitzMax, which is + far easier than the previous examples. It includes a new definition file BMXPNG.tsd: + tilemap.zip. + +
      +

      + + November 16, 2006 - Version 2.55 +

      +

        + This is another update with some fixed bugs and changes. Download the newest version from + SourceForge + or simply replace your ts.exe with the new version. +

        + +

          +
        • Fixed: Replace Colors (Edit menu), Replace All didn't work properly. +
          • + +
        • Added: Quick keys "0" - "9" for toolbox functions (pencil, paintbrush, ..., selection). +
          • + +
        • Fixed problem introduced in 2.53: conflict between bounds and sequences (certain + bounds would change into sequence code 00). +
          • + +
        • Fixed: starting a new selection in the map doesn't change the bounds anymore. +
          • + +
        • Added: Sequences can now have bounds. When exporting data, + #sequencedata .. #end sequencedata can now contains variable + <Bounds> (the bounds of the tiles used to make the sequence). +
          • + +
        • Fixed: <MapCount> was still not working correctly. +
          • + +
        • Fixed: config file not loaded when starting from other directory. +
          • + +
        • Added: transparent color can be changed by editing the config file TS.TSC. +
          • + +
        • Added: Paste half size image (Edit | Scaled Paste), perhaps more to come. +
          • + +
        • Fixed bug introduced in 2.54: #bitmapfile used current directory + instead of target directory. +
          • + + +
        + +
      +

      + + + + + + + + July 23, 2006 - Version 2.54 +

      +

        + This is an update with some fixed bugs and changes. Simply replace your ts.exe with this + new version. +

        + +

          +
        • New: You can now export tiles as separate image files (use #tilebitmap .. #end tilebitmap + within #tile .. #end tile). +
          • + +
        • #file now creates the target directory if it doesn't exist. +
          • + +
        • New: Replace colors works differently now: first you need a color pattern containing + the colors you want to replace (or make one with Ctrl + Right mouse button), press + Shift + Tab (split color pattern), make a new color pattern with colors you want to + use and then press the Replace Colors button at the top. +
          • + +
        • Fixed: placing a mirrored tile in the map sometimes gave a range check error. +
          • + +
        • You can turn the back / mid / front layer off in the map editor (View | Show + Map Layer...), this is reset automatically when you switch back to tile mode. +
          • + +
        • In the map editor, you can copy the current tile combination to the clipboard + (and paste it as a new tile in the tile editor). +
          • + +
        • Fixed: <TilesetBitmapWidth> and <TilesetBitmapHeight> + are updated directly when you use #tilebitmap. +
          • + +
        • New: You can set guidelines in the map grid (Map | Set Grid Guidelines...). +
          • + + + + +
        + +
      +

      + + + + + + Old news... + +

    + + + + + + + + + +

    Tutorial

    +     + +
      + + Here is a quick tutorial to help you learn to work with Tile Studio. + Most of it should be easy to understand for anybody. However, the part + about writing your own Tile Studio Definition files is meant for + people who have some programming experience. + +

      +

      +

      + + This tutorial is also included in the .ZIP file, so you can read + it off-line. + +

    + + + + + + +

    Download

    +     + +
      + To run Tile Studio, you will need a PC with Windows (any version) + with HiColor or TrueColor display (Tile Studio cannot be used with 256-color + display). Tile Studio works best on a desktop of at least 1024x768. If you + have only 800x600 (or less), be sure to maximize the window when you start + (so you also see the Tile Set panel and the status line). +

      + +

      + +

      + + Older versions are available on sourceforge. + +

      + + And here are some examples of .tsp project files: + examples.zip (includes Worms.tsp, Charlie.tsp and Sint.tsp). + You can find the actual games (written in Clean) at the + Clean Game Library site (Games section). + +

    + + + + + + +

    Examples

    +     + +
      + + Here are some examples of how to use Tile Studio with different programming languages. + The demo is very simple, it shows two layers scrolling at different speeds. + There is one animated tile sequence (used for the water). + +

      +

      + +
      + + Scroll demo for several programming langauges + +
      +

      + + These examples contain a .TSP file (with the graphics and maps), a .TSD file (which + specifies the output format for that particular programming language) and the source + code for the project. Most examples also include a working executable. +

      + Note that the .TSD files here are only examples. Normally, you would write + a separate .TSD file for each project. But you could start with one of these. + +

      + If you have written a .TSD file for a specific language or library, which you'ld like + to add to this list, please send it together with a working demo (source + executable). + +

      +

      +

      + *   The Turbo Pascal example is different from the others, it demonstrates overlapping tiles and + the use of palettes. + +

      +

    + + + + + +

    Forum

    +     + +
      + If you want to discuss anything that has to do with Tile Studio with other users, post a message here: +

      +

      +

      + If you have bug reports or feature requests, you can post them + at the SourceForge page. +

    + + +
    + + SourceForge Logo + +
    + + + + + + +

    Links

    +     + + + + + +
    +
    + + Return to Wiering Software
    +     +
    + +
    +

    mgl!#T6s$1y%Le5_FEqU z&&g(h9e6K?n}YDHm}V#B>;eW}vFgedz`uRThOIC|wT^DXlq<~s9HKwSWF4}={#@xC+n z97|)AASfPU}f!hp6*Qhu?0V{TJk;`I~+(j{p5l)tp_MaN<8wz76|JG=qc-NJ8 zkJAG~p>VGEw4JGfN{3o$XBf2xr3#z?McOy7RYu!HY5mCQBKn9AieDEkeqUwZ-heLP z4o5a#_P~*imwj-}ZM+yjKV;)22W~wa*?2hscO1@Y<3*3E_`vyzw_Eb=?l6-gO$?5h zJ%27#w>pW2mOKP9#vnI7flD5+U95EDb6pk8!i-+Uap_RFh!VHl_;4-wlz7;kcX#&g zOnWfdy=m>9@6MB*-|y4}sB-6td0P>q$pUQ2_B+Jkr4%isBgUe*aCq0_B%A6BFDVg4 zXqrar(J_w2rDK%0Y&^bzg#NZ1hqi>e9RZ|SWJ-#FHAJu}7tGPy4TS9PMu*#-&88*c z1uGntyc$zdxcYMk#Fet1kJZsAi=6s>jO#TjTk%XTnW2m5+nR6F-X9jHTJuf(#QP}U zn__Moo}tOx;>EXZ_>*~3_Er{j8>Zsul7c3cs$CC&ZFm4|*#ls+9so;u0BlH5)Za7i z{(y+y4}jSRiFTfRh;D+I=*c4>QY`TV_sk~jNWsQ7P@sA)0Nyp*>GezTp(pR=>w^fE z(*#n)Xq7Db2QhQk_h+nc9rajQkT5AUaYRBZ6!?KRMB zalnUn0O+g_AEbf03Ljq{32l|pzSbh0@Vlo-8CsEYsYow~5??-8`*OZG<;%xw?{1=Z zTa-(d@lCOzEl?I9zHG}+2R48utK~i*;erxi$Rz)hQAdcnp?&tLsBFh`)6+oN+VsoJ zR1D9yQFRgmDy!E3Nmi4j6s%hmXc?zvA3W9BHf~GOtb`vqRD~pN4DxM(hjJ0lU7ls^ zyE`sXft3$)6`szxpmyqfIu$#AZXKf7yV6P7C9~(xN--|Y)J!nhqtvycl|S#_Hy)D$ z*u9WPQ&X2_Y2lECDA5RTm~E5+e6}%p>Y};0e{UA?W?0nl=k5AlK#byX{sQqH z0{7rSH2Ht^Ozi=j9=4tWJ}{6febszagav?rDR&zF<%x0INn0x8dNDbGPb5>R0X)>M zlP@g-+la;h-V#b+&h2@3`!hbbA!6npBDp}vy{*V^1e_%D-Gm19Yb)OmjuLf6jhM| zf`e^AS-;U5KblJFs-}skAYKR+p$~$19PL(h;N8huc?Z7N{>?VG#l}O-!*@YXYY9z@ zBFBz}q2;(3Nbqxd2&axbMC!jh1+LSqoc;faa(*p_cjWEe7UOFw;C%26Y2~vc_wSMZ zJ!BS8s9UdITE2yD zlrK~#JMo_WBPFn2O_adRUQ`%sem%tGPJ9GZw)S=6F#(1?_g8Hmw46!v1@#UW&YgLP zmUDyz%beSY_|E)=JfeWJSOqlGEXv1bn%YhhoMm^gEz&2nJmE^kI}XxohL-*^uwH#c z2EKA{U=9UByBUo$6}_{v+C<^M6{o4C?v!=RB$>BOZHZCdJBhX}h}EO=Hs19jQnRTr zJqALntd0_UyYPTMJtM3bfP8E-Rw9Gya$$GBv9yG8`Jw+kq_cJ#GU+I8ci|oV7PM@Z zem|r_bo81pCB07!2;m8I1zHH-rAsgC*p$-qVT2CkQZ zxGM`bilAmHHiYs7E>~G`;#?@-r@cesM}C>w+DC9MP>{{=StDjnqF%5uZKYei&PPd3zg9%EiMqz;k;YuV#Fpzpa6uRzdGMj>3_(;2302mM~SWByr))|G2*juz5rI< z2KC|w4WSnt2%)kFRbqQD-XlbIynjlt#Pgvcwvs^rT}LHLrDhV>d+~1IaQ?mdINgr2 z?B3i%H{k_Drh=IjqQF}9rhGQ4zk&@{Ru4uq)LgXT=|dU0PW>8@Dysu25II`9%nvdU zS7FFNdq?q8AKtNbRus^-w~&P75+6gOMX$c#{Gk!td*G;OE%OBV$v+$@J?c1~wbKfq(LGS|jV91amUy)&Ib+cssm)@ zVERucAQlE@OroGWJ%C9Pqq%2f!aq*E4#2K@#G0d+zCgmV)Sjzs`v(0GOQWQM!SxeG zc|Y#o4zV$mj4-+SXMGA4d9QqB%7S_2T;jcQ9JgcLGkqx0C35xb1L<;X<$iyntso zo)K^jc=tovQE-#sBFCeEZW2FD>qCXGVfhWk`}Su3$MF6X+&+Z=T~0DA_z_IiRwJ)z ziP9o!?o^av&A*nD>_HhCmLw``XTadg(nQ5$CFDyhU?4^$NAWPjhynS*Hphg)4J1Q51+hFc5 zy;1O{i@t+-#}8xcbDz9?P|#3>?n9Q6dO$mb8wZ6+irNPnfzZW#7~v&_ z5^)rs?}$sYr)H5=ecOb|gk zaXIwoLwK9M!6TX|a0=c_n)w&veGObXQu{jv=1nTOS5jBFEl~-4`d?FE#fC&B6LI$A zyX|;t=Ip30)Uu!ph;2xIch$U^Qij{T8GTw39~H|%d!-UfBa!wNs?)*R$D7f-Ltmfd zrn(?CW%_;oRQRU=UNszD1zrAPEDVflMu`4b>oREvWJ3RxT?9f=>L#WN%9c8b1wf@* zk21pykYrDe$^rC>XnbUV(@4l)qjY=4IVRh;^*hmVrUP;F!8&z?7xy5=I83~i2vij+7$Z1grn;w?3PXpN)`1rR$yjd(Qw84UOO zqv6j%gaQF-2!TFWX`G#b<1cQV#OBAch1NB`ztJk9|@wvf$%}`LXn|Yh+fevK=lL zE<^Yy@gnDtcuby(m)pVr&Q0|Xu#e|`}BoT`db=|F7=IRfT z8Wg2Wo;wM&gg~!bLE8y5oj}_)P=2MJHXuzNTRbRemMqLP0f~Km^H$U3FBCaLSw%bbaseUoX6lD|r=$^xZ-9s;9?uDbPUhk^R5j89 z3&&*80A2hLJSU7-g9ecNF5CMp+@q~}AP#O=J9d!hNqtc~`!ElPIE%W`VtdIr>zuKV zxz7!(qAZn}3*~tnOmLXF@(U%f=2rw9ED^sw%zfKZB?dMNjjnk|epb~(1PEh5vNwkF<+{KFnAfSU)mR_I`9Kx~ zmT`}a_zy8MnTKg2&kC_JnPchWi!auScayp09>{c2ZF>(9z9V@z4;iQ7S5)30&k0AT zt6Rmmk-V$+^&zolq%~EfG?Mqw;Hly_+k2o08pUtv+KP4ttf+5@_YFK^n3Tb1{DgEN zgU``q@a33**yQgGzufw}{GBQ_R{ae@Qf_>vv=KL=jK)m5hnO~+ceAtqNo*L+JA@FD zhTO#(Byoh4n|=8szOd+A4w__%{drILz%3yS@V0!;#-SDB#9>ogY zoPM^c<(W?EXmhxWrx!z=RFWrEl#LV-~8>CJdOS`o|V;m#NbpukxMk?i5;mt z8gjiKQo%rbZ%yN2ZUZpsCPBh0wG?}=h)UyGu(tGS8sDLPbV7_C%O8hzsLHXBp6|!N zfz!acWQg(Ocsw%LF^&(%3HU4Hc*izIOxM+|NFIy!gZbq7 zTm+``M=+UNkj0HXJFHh%loaS5oGep#QEQ_Y$6H;YcsZt4X~f1iF6!IV7Pk=I>T<);-+R&^<>U4pd<&sqXmE@?)U6=kAL{nug5 zVv!!M04UkGL|Acjvni1>)Xz^Z72X7vH@_7m@1woUier;X<|)?pmGC zySMx88;k>jtj@8W4icm0bd4wGCm80og|*g!X6AHepvus5Mv+5k|AC!dz{yB$#1_A znG5+--p~zVR zBKlnxnR z?31OC^+7gq`Uw>0sJQV2CLnD@k7axnwkh6N#zQ)vS!->%KIbuBmZROkL4x0>vC-tU zE_I;U>B2-INv;!~~X)*==4Z$qE2oor_|I>kiJd8^Bs~zL9{Wq`$t3|?0s=5m(Rh`iV@3sZ&DRgZycphq_9n% z$tX&IY)}d#Epj1F0(c$~z>qBh^sp-7dX!q*r>2rT3!MyFz*!z?d^(S83?# z3b*z4z-x3-!g2A}a^8WTK>F%&(P;&r3Bp{zg2(D+iZ562h@k9BLhMC4^Xwr%oN4)x zrWR=@uqP9o2QHc7m5w^ND{B*aerP#sp2MpJZ#hK7JudO5A#6O`8h6%aTe}* zESKRMu-Ahb(b$6Js$w+Qz&RRt2y`mJc2#u`mE+{Qk{aN>1yq{S%5ha=pHI}?WV-{v zLKz2QeHl&lJcc-Du$MxTTAzZ7a8sK7Nwr?YtmIxZm!WK=m)z?uSwFR_eAcQ#@`(%7 z@x&!-2SEj}{$dfu9>hl|kftF!w}QI;3GMo?N2Nzqd&_5|+6~Xj>JahXO8yXcc?x)_ zEz_;y#X2XnH-`9i`6WHXwgTRvN0UEUkw&@5xT4h>;&)VijQ$Fp%l?26Yk9US#Gz^xF3_Y=@p<7}#Jft+^A^w&F{+3MwOWC-IOc7LI}-tN zUR%W5w%Th050c;kVqXz(lvH-Eh(D*(brDaPcvswLz1sx&W|BBz0_}!~8WRtV?1^RG zy0kka?R}Z%G&uH_c6+TM2A5I44w|@32UZ~SB^83AMUm)P7qJS#`A0EoJ)h!o5?@>F zlAIQY*7NO1J-wJeiCa@I7V~MXSHDe_Zoswo^`?|?TzzU3X;1Nf9^0SM*oEY2nUVw( z%bt6R7u%&sEjYIqZkg8^CL_CznCKsii_ys)S~Qp2JJEyI<*x-bVaK-M$Gml$3h|DB zwT3~JT6om`;bnOnq08EPD;AfQF%x|neZ}2M@Hncv@x@!skE(Wn!9Mk8abOdsxHV-} zo3P;Zl8vpt|GA=6e~f}B4bR>{x-|Zq`O72F-%YJeV=`BN?N-PUh@S4Osg3BIUYB#B0<5)rU7YLL@)Mg8xsGSaY0~h#NPOk-sye-&O z(uwU`I31OFXAAT)97W9*-agXTNZBQ#P-H==2f-eiZjxWL6)a!c*ShtJ5#AZBM#L{{p z$gW@+4!yKY$;cFKwqZW;m`K^iBN8kt?j9gI0PP`7vt5Q`__x1twj3uncr&+;xwqh0~VTbhn(fvf z7JF`)2UV?DEpaw3&2$AE_9OKJkeSQ?B7yesobA{~`9!SS z&im$_+(S)kS%pX9%gXB3z&+hPio<^3Dy>mc5=i)<&LpciiZdl7#+ZWV2|Rb=c^uCu z92Gf==YIGr@LY?ntHXGnz<1?%UO@N(Jge~Bk7pL(`+DGt#*@HE%``1=*2}x*w(3_st%GG!)r|;jT z8ksyv_^bxzfqRzc1FE(~f3S6xvq-qI+8G^_Ho`#T1!0uFZqc&xDj-aKx)jMu7U=K- zG_>X0Kk;T!HIkFj0Zo26bL~noWr#Os2-3kU0MHD6X^s+aJ%NnfWRCkp+nu}vYy5%Kt73NYC>RD_v6FkX$j2uU zh<-r)b0_HXgm`Z!PYm$8*d*7a&Vrqov9lM=##RiFfL+8=a0DL_Rmwy2_Pu&$n+$2#Cy4*a7#obvm7B(r&QNuq0TRYSDb_wnvmu~5&j}?H`)XJ zF$3P+O-aZtPESh`^7ahc8JUa%Whu(t;71autoh`;ns!EZf`S4;c_Cu^i`Z?BcEXJo z_~NuUyG$PxxCc2@?Y9+@K304cN4mu#Wwvofx_D!ry|)O>)w}BI#igTm-eSm0*cQnY zkAH%9W3Jx2qaPRnezI`>wjE)*I|QXN??kB%i|sG*cAcV*;qEFpicGG(!s3jXec~g& zi6NCub3F{`>BWVY_z=6sGs1rlCjUpp@IBy;$c`Q`DmJ@CFm|I4@8N+hMi{hR>vFMR zc8m5R>r*>@umQRGG{ZxP;t2izC3N3R2-1acNAm3Us$I z(hygIdy6Z3F~bZNx|bnY8zDC4*?YGPSDZ%8 zkAEyvZa3G8Q7=Pwlqz!0+XX|Gd@Txy-TyLVxl_dZ3Ho5@YE2#t(47Rm3*K9O1^l*8 z#QO;GRffH{bAQS(VZL$3!V%)}IeKrWNQDECGuyabTpEE7SHHsD?HZj#X&=3pc=Z)1 zni{tz>Al?tDbAzj%j;5;7c8EE2)Yy4=f3p{cfs-r`eL0S`3&0!iPL_OzE2i@sVO$h(WLOFu&=CBwvlo zT(D?{re0#pV~Qwz9h$DV3-)y$^(s1 zDDc?uO59firyfCEJc;M#>XPL68Qn5T+1V;dndF{i8$YXBCn?*up) zr9+Yu3Re%88l0rW_rW`!9uaVTlazg(5RUjNYJ3v!^>DQ-JTp(SumN@x`2h;iKFPw#KOqPMGYf8CbjJ{wY#0Guu@il_3H}?p zA|F&@EBtmlqtfV(eAow2nL@;Y$UK)CPg+v4bdj-|&Y<^1@5#G`AWFsjcZQ@(q zhI)Xe;QR62Za26I73mo)TL1qhDwYU;6BqAW|NnPT(YpTs*SPpUM@1Jt9~r9&a-!<+ zt)2scE1)VyL5UEFNYAMFIpo6ilXzc}eim;qCFq7_W zJ3YaSAA;)J!ruN6OTZhf=0ja~_q&OSJ0I!-T#jGHbut$8kuE0k->vN4Z7aLyK6Eo` zApxrdX8cIk#hu8-FnC3CulL|J&=X`uJ{B*3tbGoRfp}Uwb?)VaL@ZWE0h2`}jKFRq zp`0=)QCJ70-N^z?x^59#I5Ww4gCkujwb@T-hqVpjFg%aDm;8JaHexkwgGm?6w?S7> ztpn@>ldiV|4RXn(>*>Pj0_I+Y_?uW*l`hEr2wE0}_+$h&sR}@=Wh<+&sj(6v?^LxB zAvIN44g47%iwH;!$8_b`$lijhe)dvSFbN%U7oBkzk)WmE0!&JHI?xhH9m>Y<)djj# zWf1YQbgyo(hn=4P8O_(>XagGp_slxzjzf|r7t9;%;$D#S0N!3)^Pe>idrE{9i85^58>xL?R7p9LOWHjUq<2V!dwDEHe%@s2o57B zMsTHAtn`3RS3)$`21Fv`7-=}sQ+$9Sr%=yCp&C>p8OKN?h}?nF`-z}TR^&R8Z;r7> z+R3*!0I^Ldh>RM8xg6AahF*dHR``)|Oc^V*ogB-{RZ2Li7=Sk#+i{%zFju|I7Qi~L+7HP;hMuLhtkd(Pl@4n5!mWOI^SNi;ME8x8OO}W@ESnFVfymi zr7Ah%9sasoQ5Ae4nv+bCuqHm4e|NbF|It97AC z1du8KgN$S9Y^t9gVvmIsqXl`Baf~rVkkYN_8p$qK>q0nik0T#4jxnbZaA`xM66YQ{ zRDX=CrG?Zzmzn-!oVQke!6#_6PyMxg+2-Df@5?YP|9vV!STz)s)PF*-dJX}>^RLuI z|L;%q|+Z+Nk zwDYPYoXwMZgQ$!4R_a2-S%m7uA8ytKIdA$(l@7$(x5$jUk;+$X-Q`;Y+7ia`*9Y$H z@VH<0ctGYz%=FVC^m-7J2Uv6xwi5rDn$y=n?elo&hkq^q4ZLXn<%KWeD}$q+VVo|-1gt`Kg%4yX({N0IOu{piRP`&EAA%`9 zS#+SW0kO(Gp%Cm<`oeuor5*U^hU1oLZ1hnG^;0nJOR4d)nqH+`@jwejrsJwhr)-RS za_zLc7UK0Cv{_jP&bwYYgoCC^UJ|{$r5<|Y3~=RAtG6-~pi)YUZd#PD@W&P<@3&Ll zbh6gOi^I7lFWp?4svd3p=h0^r4=c^$?CM8poI2SQVDUmFv0Xu$jko zJ$T^7CAPpG_Q2gKhNLtk*ZB;&ExF*6KKT` ztpDc_$vlG70;QTw|6KQ?Yh-Pb5F9`I3GZm;bW)e&y4B|1X39IM+enXV{`mz?yy8v0 zztrh8nmAMcuXL9*-Q6!F3H@MFVRB*C!@Lgj9gOEiu+2>az6O6tMDOVFG9sIHN_QPh zpK+(bhDl}*o!0fV2eH$Th@*H$9ge(xE3~DMO57H~W}VSRLJ;n0)%rxW{&@xrzX;a- z8{K)lEqmu1T~5!bv(Z-DlU$#^atD$T`gSe{!0azi!qsDbk?aU7`Bvw>fVVsl@79&C zCvC4s*L&hGG(B)#KGTqo!&44)ib~h8aFRN~T7vay#gC?=K%Rl}Hho$JFlKJQV-vuT z*zIr8jmfP0ce=;a7tgD5>{s%(usz@D&Uw6ueH`8Hyg7|JE}6YttJ|ybVA*GNyE}Bo zsRJI7Mk!t=U>o}c2l0l}6HUI;eV2h7AF8@;ry#@EnyKN#mUg26~%_fcJ6i2^9UQ;#4ZuraF%+Vafx&#;V( zy1||LOmP77hd3{;Ji}hP2=-V!J8@ALC8G!BByHuo1g8A~FR3N4tRHkE`UYns)miIv zi>THaFuv4cEB$du36T;KL!t`rVF!QEbrWxAU*+$4`zz4bs-)9kZx^7(6!Lkw*SaAhGIQvVBz!6ne9fr&v0NFmd8IUa!mTqqX z`0kkNXR`Hmx}Nd-;q6c>U%X$4R1J9Q$SN#!4iPHKC~rjuO5pW63a9(*)(0R1+3$6_ z5fBj$|54Y?YvH7u4v&m90qrW^U^9Ny4eYZG*SD0n3L%u)SpGpQDzPxi{(LCjeB@VT zV;2sffwTWdU0@GAwo+&gmt`0!tI38S8DgGRKAv*NvVAAJ{iCio&1J^e*m6S-0*@N7 zzXNugm6ut}Ph9?X)lVS*moxU0u9x*qZh}5yJo5z>GfaqI|D>A~@+W3@wa3u18?pXU zk(&cpcxU~@#$M7Tb*Fjtupae5FO*V+l&gAxpIp=`&e?0HMjouZ6;o8i!aWYcuk);h&LL&=%^6PkZPP zIIJShAxu$pr@_fSP_L_ml<17#bWIw~FqUxz@EFUUyrS!^K2JV}?Z2W+rMDEW>K?@D z_M)qh=-JI)x~j|9Okl3R>jI+V&~49S4RN^X9S2EQ<-$0JL6QxoED8E<#DFx{Kf$K` zuKN}N+C+fv z+#zr`DZ}Hf^}Mdj=vD&HyG4NJ-L%&to1MI_>*5<@k7LYgq#XL-z62F^`#R1!;#lY( zI{)$8Q&Cu({Lf5lVT0nRFarg)$^WP|fru)gwhpQ)@HF`fik3sseu;7M$}v6jhc3rS zvyfeD(&YvfgUf7K-6Rxssz}^Jsf?wWgjmWCg_P`JR`{pxswx2tN!%N{IH%iA?Cl#^ zL37w=H+20vXu-fkvZJL5gxP#}@~E*E`h-^n#1Fgyp&>M^phY)`2RhpW zyW0Z~wBUY60_b|Bh+S#Xg%QR>WK|oo&)LGD1u&6&4JX4^5tB@+eXZWoF4k%2=KOJ>`hCuWn62~ zYetiID@J5!B5FYb+^-}MBwrdy{bZH4GM3Wlh18lvAens|^2#~v@@?HMAa~sz4EP-8 zVF9x+hxNAT0(+zWh81~2p*OFeF*Z+ubfd)>s|92lIuF+rb;Q;H87;E#elc3Wpv+;f zTR{BeuoD)@Mgw~-x;~u<5aS18jv5zV>^ zg#c@U*R2V*lm9~w32Mduv};jjP(TEK?gnttGcYuFiwFGz#B(FRDZF$3| zJNXPjq^Zs|#`qNHPh)CUhw%y_P)mVdA-c7W@VXuaFA4FTmA((9_}gNhBk%7K(>Wfh zTr)%52tJh>(T6u_CxyOkFP43-5xen#l@zd|Eud8+J_6tsI*BD+uHooO^hg$Z!t{s9 zuzfQ(XVDMGkfF}vB+wis&Y~}PT3emPFo?W=;w(Oasc)QC?2WJ@t@w5i=u@HRI)n84 zw%{ZSPfdct6BOM-%t8hld>MJ$SiFl^0@*IJix`{&*r`IVvZ0E?g`(aS&!$22t}+|4 zRZ2AxMHS?>A>@3>7b}_vAV?gSR-Sm?=mg1cdY!VLPJ95ZnWqz{cdWsoSw$J8QoLda zK|6v57W*Lhj!t|5hnCNaVpOkB`ty~Kzf@98h0zM=Fl9f3?FGGYAd0>Gmm{v7Oo_m; z8qM4v4yC+5U;`x42;@E_i9Pww7Vlf@=W(chZ$Dn7p^D#-?h|LW0C@c94TYtE) zT4c^|=MsryGA!Wp%i}Uht&bO+s+MAF=EYFYMGpn_QReRgUEgTWv3UMI&2H?x0uS-0 zC|s5H1F;n01Vi9a%8QF}8E*j6%-<*MR&E}&#!}divY4sa%pPzR(?PhdcNM$qNDzh| zu5cAIdiha>sCwR1wdPavd+0OCU9QhG*B^_dwEzW}dbJZHG=qT~hDQ_dQucb_h0&d; z5MyeBVK2>SLSdom6EixYa6xGm&I|-iVMp>~8{Nd==hg zxB_Q_ZIn4Dt3c&-QRvl*th~w0v%T0aIX%>&!)G7`YN?W7=(nT4(xW5m`k}gQ@BgoL zjHERGOi^aDb?s3XEa&aTI88azdWb2$J8-}{zg>Lh{POrr2-};LfkwcwatE8|Aua*2 zbH+o|J7GNa>?qa)lpdYLS^a5>nKB;om~J*k$ym7T82JLuVhJP108P#HDeR?AVlqy+ ze(oe5a!1mb?1ZBBm^}cS-Cp8MJpAVAjjqfuEI+Yb?j^9LsZ7ULxz{Bi7|mEq??%3Ku)}LAuV$ z$ib2)G=!F}Zq^ie;I61jO+sjpbiA)_7K+?K9;lws4AIu6G@KjL60VF78MmDN<=}1gpgV;PjaYTR$C}mcE43%2oL*ML_ zuWvo-Y&cB~WrzGkzd(XOx(^_5PdHyA`uMO5{^Dph)L-lqM41&NAeYjrNZ_tm@}@e(u?h!QU$T#@s|ZE6D6e;-s{F|sgG7Ij{O;Yw zhke?6-?Wqt4}s1cUM!6f!s?dW4hKK1m2*x5$|5fpWqA=rgt zJ5R;TV()~A{n}B-Gltx8HvqEh5J-0EL_Z!y>j%%_Up;%xgn`MpKvgcr^#LhXL0rcjVlnunQxA8{K}@9hJ8 zi(udO5pz9JSzIIDtN?*|W9u4+J-m zUwO9Mu~|y)B8n@0 zCT1#5+}1091!>45P5Fb{k;-q}j#hr+_A2FjW*Q&{_1X(3o<;?;En9hqf<9IH)5J+I zrbq0-ssx1D?E#{HT7&kcWx9$0&;(}F%VWkiwe5SH!*`m)ce=y(czmt9&LAaRvu0jn7#MnxIXJ9cW&P#i6I zl;vQZLx=Kfp|N*bXgw{Diw4pfs)s1M*nkJbnZ36mSw-1S%vs7NaEJAIfK{pTAxJ`; zNR+*b>d;D=j3?B@ppY|!0oZ0M1|D9NUQxCkDJ!16g1>u7RtA?sTOSaI1o*qREu?wl zZOL4b%v`^PO&BZ===cmTnbIp0UCCe1o*gXCA2$>Zu+(jez~=88v|F9Je8aHi|DY6A zDvB_SpxI0)?8Sphs|b69LSGwES=o!X9AHctBK|XyM{Uoe;vyVkZb;-ba&D3hX14rP zvXnhERQxp{AE7pXcPP|RYf+5V#$3PLv}Bm*MW-I?V#Mk$u_?*IJ22TW3t(2jtcTfb znm$|%a#A__7yoRrv9M0DCr65-JkE|Gc(y3}5yEGSk>W_G-SHbG_U}4tEMHFM8@4}* z3KP>_34wwEbNyp%?kI7X2gA4kn4pj5BK9|f*v?U6)J)#c;nZWdkz7Rwwc6KFZQF9t z(6zqLO`wA}!B7p}*9CpIy0wMgeVzV^r;R{v$=J_VjbB4>PsTTg4UYwVmBSXtihXE@ zs8@Djdx4kv&aLvcLCTHO=fLkYZ{YVao}U|?-%a2pl~%n*T~##4FoH-&p{T18gUrFX zsalmrOd@B+8Cdcv1sX;WO%F~ikw5fLDd>S9@-&Pn3E^RWnVdEXLfSk997aUSp-2=u z)x61CN@2T7%22N~VsnbaLp67vL*d{`$`GoxPz_}_(#E*>!lTfAp{0^y=oP=7Ao|qL zx?r9j4))w=@kKWbP`zcj*788*kR&!DPJAGDH2Sjb#qgMiFzU~Mh?#FFcEX)K{>`WQ zlew7ccjM&F7DC@Vy;SV(1e9BpEoS5E)pAL9I89JQ~Yz0*F zhTvqp@<2R`jTZwu&07SR(4ed+vw(KdQ^3-Aaf!G@KzmZ+m=Z6>LIOK1K@1yz;-5eW zx;1=M*&m7-zA!|4OdG;0N!2$BG1?H&h4gKmMG?jA7!<5ib$LS&2TnxVoyfK)0F$?{ z9}>g>>;P}0grP*07?WbLOLtM;$D2gP^>3icO2#!5ynYjXrtnW{h%y47)=SF&U^5d% zzYq6(B|=@7Uw;mXLXn*^!ce-vXqi;u0UD#EdG0s5#Su~uKX zi8>1`7V6S7=xng|hH>Yss}Pcxk3ULC@0*tS2mmwXOl2eSzfTd7G44zWV9(Vut^})A z>3pNb;;>3!i{gweir!%nv3prjS1lK(j0Uc}cM7@yciIKv#5!ItWjJ<+1 z5^wVDRI%51i~}VdN)C-8v8QqSPi5LDhCktF#vteC`;blG*P>|xN<~Mg6VQCa{$c1F zp)drLk#Ulw>|=pr#GW2{#2{K}OEc9Rr-x(2H#9G>)-mG7taXziD?L3~DE~KR;*_?q z?;XBv@txrJTXtI<^6z81Fjl`?J5Uo~m+4VHkGKb!VU0K>rxv;@&lZJkU6z^Du`D{|Q58RE7M@BEH_;2K_e zcRT&gqBD{GQI?Y_26tMF5nUu3_EVTp*cW5YlRcd&di9ODO373t!0REUaM~vAyf0>{ z;PQc|x!#-AWQu9D|1qq{7YcjgC?$u5Wr-i*9I7r$eA`J=XR4SacF+K#uS^D?au^HD z7K7X{ehtu%>S_!)kif=fi@lScm}l!K@CW@j${;JVPI)l0uJzDl?pck7Y9?{Dg*J0AOY&^c<;bs9RP*U(g^_`;J0S#pb(|RPYP@~TO8D${m4A?kb0-zgy zR&SDP*t0pHR&z{;bHwQyAZ@@5kQ8$lsu;EwUBDkQnjv<>U6?Wo``jAVg@^gDFK39+ zq=)-CCSqB&zGjf2*PyTV+($LAscN5B@ZwP_at%a4Qo2>47jd1=VayW8a!OX2bgVsR=d?CNav_a5dsN9@vn++thTqB{Hm_X%el#%m^msh+W?s0vUA zI!Em5gEgiodRV{~*o7ElPnbPS+QhAq?D;vEbRyZ_Iif#5cspHV1J6V|c&^M5^T7$qXsr0 zUn~tcS&T7!um!lPYU!$lJ44w6k5>yK*jM>tYzfGg@;L1=rzQlMD;wdo(p6LhEtdr3 z1A*Wq;|JL}T2mi?)P`{u7f)J+!);Wzi!wbM??tHuGpJpaq`e6;rE16-fV8C6VL$dH zvKeTu&-@b2!F0g5~DRe>fBOWqN3&aj};wB%O}VIMCNgG+8YR3a4q zcAOGcpe6M`eWB)RtTyzcV2w=)SQLU)g23Vu?wD=}PxqEXItsR@Ti}omJGqj!0t8L!iFfS|E}_G&vD#n5wnA~QLx$0g6{+U=1v}(N!5XvgN?b3n{a8D1_fE1u zynNx6%^p6j2~2!rb+S+kBWI4$CnhJ%E}U(wE_6(VsLDO=TDVgvi|-*<8%NLNKK-S} zr$oO7g3%=qaP^53w&2@sCazvR25M+MuB*We*@zosF!NwCyTl1Cu&XN&{uJbhVTN~& z6M{B@@`pK(DrF;19ZV+TWFtHpb~tQTURC~n=_aZgE;CczUAYg{-JfX+#Li*e-)^z+ zXBhxJ3~D9H!HuU0$GOo+&+>#4rq}`ynA6y#0x`>N^zIf5eJrEDUsW{R{+g@|ZpKuo#lO;3!h_r;;S) z>re1)mC*YT-`3qne?(D-y>;l@-e>ysQ=Ycv(6&hS*TZ5;*Awt?5DTQ8FJEhvk6F%A z(RZjn6_6CFq#eNC$68S6MX-p@t)T};A4YQ95^2*;6pC)36UU|EFdcuNFOpqdDh^e@ zAp*KgtZp~FG+8(o?|Jd2a)UK56Gwsm8(b)+x&8P7iUXn2a%e{+d#X^3^vVDhSpk~Z zdW_G^X{OVKV!5W%8LAuBsygDvoI_2NK5WTyF!=(C0o?L8fV z2(;ei?xVmDD9|o))6lKHYjul-rd6T}$MC4FN}PycIRb6BXYvR_D#}Rpp@Ij0kk3Pu z&sFqg8|iS9Rjd$0b-Z&RM708k70;VmR*1P8h!V_LCHC{^MdQ;lU|xAJHK3Wjuu5Di zm+n>D^NY!QwYc0#ch!gn4Z+=RF=3kNBM$%4;$We$ol4*E*O;&_?nn7A*y;yrJO|CQ zwL?NV%HsfrEj+Iue602NgB+o`{zFq_sW@39$v_8eVYAs&YsDblNz8Q0PWItiafaXO z_j%b^eL%_qVX{LJk9X5R*8efE-y_-d$FO?4vS%I>3p#ed+)+`sgCMjY%c{BlYvyGT zR}Ve}e-*n(V@fe?or6Go6INwIT7T;&Q{O4A@7b$KPy^!qw-vUBg0Ey;o$8$>q7>d9u73x#gSv0=fKCULq@KL^5QbNAKraWFUPAc%&HL18fBh+wc z2+-N7s0Tnj1cBB!ki=Mmm$P> z>x7sd?s*z1%t|}(N$a1*SU0Q;)fBlMOVYk^CRwOAs6I|bGJJg5^3TOyK8*-KioJM7 zuptT2wbsB7KF4m|m!10@;uZr<&z%%St!9AfN{j|l1=$eEcH146M;e6eu*r%9VX>FF{49N%4KSebh(Kve;U^Hm6X|< zY^r6vHtjmkEM8mM$RkQDzh11D-2Q|s$<5a^{WtNFHmcHR-&h$ZFUq5P#) z>|2erUTOuILV;|alQdLnQC(H+H798xCcLvwQnKa@>+UQCXo^jvoF$DDPT)toNJm39 zhNTcu3&Ac9A}|X*xAlhCXXR-jZViRxR#;!16wql;Ac{x`aU%#cBv3#Bo2HX$@RoA8 zD5ZJ~1es}pgqUxI|6_ZP3}ov>X`5z;skit$y9v{s*KUL%+W#+G`0Z z!hdE)A$cpzd6Umzsn$7mV^WGx5f^kUPTM#doe(DpG||NQ?--RLl#iJ;@UvqAeGWWV zo}Dn-P^~rG^jvl2SX|KX7>brXoJGV){je>a9wUW!rkHF0sspeKrL}+k4!g+Z&~Vc$ zF;bHyCe+CE!m*MkWGh z({AJ`@>|3G=D}|q`7I^C+1xK1enZJGZV3FMhM4BYO8%NIE61e>Ctx4whmOqc3)eT!#O-L+NRk~YoaEz!>= z%QJ^tUPE}8Z-FUflC;&;qhKKdAO`9Wyx`gam3_RRC z3rJ{KA>rH)C2S~wmsw$8^)!rwJCwctpmZ*@d8(@NAkNxN;e&DXiemF7DZyIk^R`XY>#D*Ja=zqS-x zR^6S#8mrxMsjCa+(B=;CwH6Y(#+Jl|7s8_q!-BJNxpZD^w+fY3$9D~zvqsA7ym5o$ z@U4FxfH)@3V<*>0p_qF9TqE`A)LP~krD60jF@X&zk-{MJnNuP)*ykaV_0CX?Fh|Mr63Y8bzfPx}+3#YzP9} za}X1qyXi$hH4yIIPmqiDnv_*GNyF~cXxa=v0i0T zFV~GPz>UdT(wiogNndM$cA-y5^Rf1_r#4Ct!Fg+=w8BYqz_k1+X@D~prZ=CF#s>IT zVs^?2i9PEQgs~$Q?Nm?sdcDP) zw{s_I*B-U4dY!wEo8~?%{YsS_`+}6^47>6rNzy_b^{q;&Uy0?N6e}%faT$XBbCIXf zn`q_Ao#(LSGd}9Th|s;80s`{<^Ua(Ofh{1NALyHohRS=zw6CBa|=UzZ#w%u0z9 zB;Po}Yiyiw97amRrW_k{{W$3Cm>4G%PmL4Orp56Mymm&MkPWi|d7XbRg>T@s@23c9 zv*YkmGSa~=Mjo{=u~Xs%U1r8qeSG#Ns^K`%>Z0nC{wG0j;h~r=s+D`1kcR>sf7x)y z!o#6S#FRMy;s0Knb|5bsQ$qXEzi(4JwN1p2D9NRI;z1kU4$h&VhTPpaJjrX@n|Iv| zyuiMmHazGX<&!NqTw7m@}t}~2CgD+0vD#=!K-1}AfuFS-r=6-tqH-`d0TLf&?asQ9& zoRocV@|cw8U|UB0jo$XuDY!(_4Lbp20OjJL-4&3N!#;RN3hVUh0b2|5_TUqw#{2Br zJ5uMd)o^9xoyTAM%jPKzxHIk~FpM9sWpxB!s1evpkXUcery}w6J_RnN`%h}nc&2|B z=stq2epgEKMEQBM=nu6jPoKlizAJT0R7DD0vf)?M$uNQ&Axig*(-zE9s2qb%#6zD}cSi_G}IAzL=yQJRt*Wi;~Qm`K6s1G+ER8io-m2onnZY=G^^dx*~5^hzAEHXLaatW97MyCt6oUpAuSf3aah zLs0$M4b7IlEr5y*cwU|W-Y!H_dTk^yS#OF~APSeLilsW6>$51M-|fL~AsF4E48zDX z*AHRu?3RjEoy2h)Fr{IigwqVv79@-(F^r;(-qhhXXKW?9J>xwoU4*B;62O1+J*gYX zPXm|O7w<`Qm89i8DaapQPDLG`aNeM8ACJEY?KScBbP8b@k&|PJeqV~v*t1ypfz+!+ zSlbLZ1aaXx&bmE`=?HthtdlD9_VthLXjX+!pxH%CM0%wK2bq8$u59rOZBcng5DKXc z{I#Q9AsXv|c5B@LIe);jeiJH047Ddd?n=26e~pmu3KA~Bbp`E^xkWSAB6$g!JkJPItyoACOThEVDG1Ie1#k-^%gm-B< z%;`gEKuHR(Gd<)EycmTbw98!o!g_R|{W1kG;Tr=mp%rm$nBdtC?Rgu~l;Fo5FyU!L z;g~R-N`W#F%BT$!-sPp8R2~5KnCqk0H?t2ulvbq9-K37Wx=(EIhIA9*FD#l3U=e=6 z;&_3DAeWAkbyhq9%EXcb*s%N~X=n^@zH23Apu98>U3~W>^#r`^xcMuJBwpNYtSsjG zTkN-wq#h*(%z!jKR2;R{2hHZp#G$J(hb11U$T|RII0N3~-4!(^p0rl6hSzxQY8>xc z0*ibri^1nN3a?V19dn^kiiH>)uF4!xfOq+0L*#-e81_$_q)D9-(_>fG$>!gjU8p_A z(;mCLF&u82q?P|J?8z!=*S`zP*elKU<#`sJ^w{;KvpZ#45$)@-YY=ihxmPMLiCIAq zBY&FKIS?CX-3P=A@UjDO3*baR)B_dF_2V(B8XBKSY_{{8t?SOGc5qr;5|F<={YeCv z>pN4r7I#|P4gDxwV?NJ*+$RNwwIaNO+w9rnW*5Zg=I2k$olD!sTKEFG7JNeanL`=w5DHoWM! zmA$lI3d9!i;C`uxyam3L&1F^(UrBqM=QW5m?w5QsL*Q!fPPK?zP`GGz0qXb$;!^Q- zNJj-0!=}?VvV*L4C~VtPE_>iV3vK~fZ6KSiIv{nCZATZf4gGWBXioSn`k; z6=IsxRw+NSz-p-r_rqrM*~3zV(}rhwDlv$sn#q1YEQQMZmZ|akQ~Xd|!b+*ewEPV# zCf80@3CmTq###9^3#vvz4b_qdv~J(3mL{d&!c<|rn9|q0DmoS`hZe#PB98oBVzOJ8 zx+t@kHd`vRTh&+Zy$L~-^_Z~@N3`*lv=D94*OQFLtbv3i$^y3iV<|YjJ(3x*eBA6l0N7InoAnLw9O^PcweQ4 zNO0&r@lTpm5$|iQ5}}>46zc}+YmE1=(3ToA@Ic68xV~h@af)InK}F)V#&HsEA+7;$ zr6OM1=k^t~gNL~7^Cd?P97p3lg%2QdGSz#^lzHWzdCe%Du;%I-!iWa;*C*2O!Ba7* zQ`I&jl}ZnSq{B-X$-c@hP~G%B^D)p~P2;P$ThrVH%sr?NfQgBSbe%xoK|MqxYK`%s z%0;X|)B)jC(@@8nma_6sQPXGG{!dZU1?=*tSc%c6M{PAdfK^;AHB^z14b}9n9Cn$e z9+iAG?Sn8>l~im0KgvpvNj_b{t0^y=g=q(%E}N&?i5s!J;92Qo;Oq=#=Z;}Oe9PJ$ zmx44Ovhd?lzdk&p=dhI8XUx(wfPNW-B_J}yL%sM=pTi8trI5+>4>d!uvm(jM+Af-b zlr#`!fCc>5)9hjmqRB>yY6~LiHpigOYLGF>S4n4gj-%5eShvr>H}hm8V0FC?U_i~4 zFBO+>O-K`^vV|3WCT;D(i@t$=;yCT5uQ1$O_*oWtLh{k^iX33$PDqpe!WW=({2!y^ ztmi0t*(nV0I2zy`+2IpX7flO0dqR3flgsiym%3`ku*W}_dO(NC+nxuT!-f_D_QuAFBn_x*$wiO2RzU2i1t2=2->C7F zIfe0D3MiLq*5OO3i^l`s(@1Jk-o>fmk|)ihWavBOA&3Ht1p z(v*lKnko~AgCsE~4k=Hpu87xwlsn?s5g(v-y!<1|6*l`TsjGL^JS5VZj9EuGV3$%| zMzc*{Ny~5&qOAeCr?99RDNMKFSJc0P&8h*AH?oyAQaa%Id5!dw<`wqt*V15DU^6(m ziAR(f?Aq7TX7C6Mr=(yvczcwcN5@qjAIjc4g}vh=?AudPg4;)+8e+6h-cHuhq5+xSa;`R{W5iW*$^tf z2szs)g+gRf!PBccy-v<29O4)6U*ezCTBA3|%4$@#qKqT^+WF1i_;#2~g0PaA>ld>} z&PmJVS5YfMydT+(b3l!3*5kYs7LcN(2s>cr!7PDU0aFIE3Fbw%;JlRH5m0jb? zkBX!rv~oOTI&mJGHO+a`pBJQh4LbdYAEamZ9tU&RTfrS>q3qH=9)_ zl^|MOoir9!_>a;;UF%gqY69E#qtw0s>50u2zRIbKoPwZ=#5WW-U>RiP6)m@0mDZWm zoWEGZk05Y{GM}HM!LZVQ0%v(B%l%237Q!(s9h#!+HQ*bMHAt5+5x>boFH8R7#&m2+v`@1Rm!-}#mcW7cLdxA9 z<4;<(8lRyFy>0$Xr*Q3KkWs-djYKr=36D_2A$JLmw6UBg{tT1v1ncCB0yTfK^JLYs zo3Q-$kLNjBQ>1#8*`rso$e%G&J#HHFGrBK4W*j2=Z#J&+DzhNRWXiEO{L1|wH@?hg z`E&5jAa76h@h?(m-^zH`llS5gEf{{9uO;@B)zZd?r5liSTBX;u2+6#XH-C8h(ZdasH zZuL{q&O`+OQGjxa)Dxom9qOetw}&Vo>oP@+Wee)1z`>Qst0M8T%CujSO<3Ea#KSh% zj|OTtT;i7!Y%)7so+{o;d6FHjmwYF4{0Yb4Siw1-%y>r$4^ zGaBrPfo$=0say1wf%x|5+iU^vSmir|&5RyY8Zy=CE#yvHze+R`v8AcLE_ro0iJnlF z0mG({=b?$sZ0(qK-THnp8dTsD36U0ME`=qHEjnkPi2EWhqK)@rG@0v7tp6X{G zzT{-xBuXH*RaN`xMAhnPTJ?w2o^EXz|0%`yeJcunUxX5;o4Ou?w46890s_`r=M8-G zO+sZi|0#9X3}AjulArv-C;~>6(w>cKl6rgmG9B6cNNh-|cP%Swk^)1ATjT7ez_+b| zyi1B{;00KNpJoS|K;zwD=bEIR-W@fm)EuKX-!tj>Y+A#-|CD;Q4?2cPZVND$R*0uq z>Yq}K_j5e@6%eKrcxMv9AdNl$rxetlw!TVdYjh1e_9sYP;M1QNUf2@ckdAsw&QuoO z0p(FQW>MnrS-WN_Se^@LQZbS2foACv-pA_NB7NR||5&uT(Qwqw7@x09W&doE;`;hv zRaC&|MbqIa)9TBg!VHEKdKSFe8vHPubyHgBSAZ(fWs2R|3SO_WOvy5SKp2IijY-UM zQwsMOtmD;E-btnkz0HRGCH0tas}G798H}X3yse@YJ>3K+?_lux@ahxA>54c{BwA6A zP6sh0`AZ#wm}=d55xNXy?;_iw%_+z+tA%_{VjPd9tC6&Pjz!sa6cdpWa8joZ4X@QX z=6Xx&84*S$=69#K*vvu4d`04I71HL%msTl!fN?NpDs7dOuBxSt^lpb}ZP1;Ah=h^fvPW96 zw~1txt%tu=TykrdNIQF6(+#Ug(-r09OikLt?g5VcVJ{@vS4p9 zi+y7O{laOoU!L`lZ|eA*e2cZ$$YGl2*$|Dq85_ux8hL;h-xIlDD&aINIv`((VI7_1 z5Zr7U>?Chh7kKQFo#b$0!Z^!es#h(Ga+X6uKu>j+$ChA4D%VR-Om8mzC++T4y5}b} zt3ss*{YDa5H=NUXyk7f&Oju$RCj^-5p_RkZaK^T(;0YOZa-mVx-O~m{i%TA+{UX<@ zc{KZfHo^hxNoGT(X!TMrXrz4+1GE)d&-`S>QJ(?UD?$xoorWjrAu)pJrn7Rogt+0oGAB)TB-<9?g@QVS)%Ny zk7|u5_qb0L6|`#IuZrqZQ4UUwJa)Iz3O_;2oINL_a7h6*BoqyahOyP0YVR+ISp~e( z)V7TX-O9ox0D-HsdM*z&Ok?@*u<4oFSK~x_rbf+yMyDU>+p278d!DmZ*;Efz&s29< zq+NA`1InX!+mrK96p+TY&qU-Ch*09+xosE_jP*WkZclv2!O(*^ z=Tj2y(@vNDT7q3sQfSZAyN1PqRsXr7!4PySMn%cr9u^5NCkS;=?UDmk8~@p`uqjG% z92WC>r3yi>CJ3dl9Tg2m?catEvCU1r zp&yd~-I07mg$Z}7o52X09(I?)7OO%O7u>J(5M1Jyc^H zxFrulFC3J!kuEq44-dAK-K(s{XbXPXH~2^s@CXDF|pAX*BXeuuj;2 z_-+qFC$U@Q`1?klS3#nEll=>=n;de0u4zcKiz!pP}93g>?^M51gVB?BA4g+ zbZ)DqvK0_&uIWLqiwjtR@w&Kj!R?kssd9(rbtp!z)Uqc#%5#9)*E`Cgp&`gyY43zv zLAB){gaER~3_>Kiw$-lU@ZxBKJyY z+&^ENQK?Nf-Rgo`;?d%*hdx;Kw!RLOy zc?3mU`xCj#vzjRK&z2jO^NY4#m|pkdg~Ynro(Fh_wQxwaF816D+j8H71j<+RXJ2G< z3ATxAf8p6DQT7zi_}AKB$%k^^V9UJ*8P?cxKmMXo`%)=I#fgH~v-DNrrZf6i(3kTc z#^?{ZmsZ3(|MUgkoAX~r?LqbXilykXrKnE9Yx)+pwY%&Wuw@(yt2-~Di1R7Z#g8vc z-}IvKsB?9N_S32@tfo7Vdke#M*dJEUU^%&aHE-m0)Mo@g4|`vwAOIpCzP7&N+=esYHW>O*JdKCpGP?hm3qc!CdEkox zqka`zzXskohSv_@IF{H_yN9f%Dm3I+V&jH+fJ|a*c|xT6`0QzIv!x$VZn*4xF7Zt5 zAbk{uT4Kuu-xv2|Ea0=r*rG;#8~YxafZWun;-2WEM&iUsaCamM;~c_#qxn z`_$ek7b_{GTy+_)X_JahQLV42wN}(xUsh{5v}@9 zhkFAALg>M*|AvynzpJD0elqa?R{aoGz5gA3nS>uCEl~(qWdf$_V0RT3n$Gr;*K0hh z07Z%GR)sdGZcrk(BvcN-RW(>X?MTn7zpyhVRq$p{hsvG$Wfgb{SB9qw?pzNQ)FE@* zONbl=zpR3JP^ShRTgw;ZKH@7}Vb_pHmsSLINL^I0WND$g&T=KTz5=uXhRHtKw767( z#n!a%?CdQZVHsg^_ZZSMv9UHzsPRq}T1O`c8&BgJb3uZz6;$ZV%(*m3JL0gA^IrJfKE)>hOa;8FUf2N>P?hIU zEW>ZWtE{@@JM!=+55_&#_}e|!!^2oZ8PVjXoW`79nHJ9q`^ddf*0w%CVK6TG$UQtl zDSb=VW=qjPeoB3(4|p33SZH54++zrZZKg#ctFH3O5jMB4yi~^%bY$oH%Kh3?Cn>jj zbFRm}Y}PqkULM5#9#Q=URvR}{C$@2}dx>mO1oY~f!)2c^0r}$~XCDY~K?(3CPR14G zx)<4vDj!IKCvNLA=YH}JfeS-W6VB-CP0vjjc+Mmn!g-rDOw(Tu8QvR_VsQ*jfmRL{ zuhHiqfQUE40~8HnrQBP$0yew9+y!g#%Kq};pcjan#!HL*7o`a<>{NewWgyS{Bjkp> z?{6&*up{J0OEv=!tqbu7(WqD6PIy#cIWf$GO9=rB)l$@ycYymg8Vz~m+n)P2<{gJ` z-WeWr1?O$eSrqw-HL`-KSGml+lsttZfoJGS;1mHlIR`X?@G^cE#ZR-5_ zkpj+9<^$#2ZZF5$fJSPG3@HSYi+-(WR4bu!WVAd0s601Xj`Dg9QSHpqx$e}o5vDhy zIdDlFO3ZuF83{YG{shc#ibEThkd~;MS!_}4yXYeaYMlxb1nQG ze+R~Z)svbkjE7CXZLs}O&A&IzgV*%m)Qf!IZvTHY&6hwQvTeKn_w*wF&!>4=cpWfm zp?O|lbtB{z-sj!0y5I@C!mCCC%79W; zOok88@ce)RF@g>umN{pg6$k{6VK-gBCSR0eH3Oiw9@Y3;Wjr(l`6C0w&Ut`w5B3a z*{7qr_&5>jUuR9D^oH zU!f&~1%=68&YgsCHZvZ4WExUL+z>%Sgbfii#%k&yQOX>j`v?s_>OL>_YP_6*H>aB8 zLCu_GT@qj^EG9wj@6fnh2jRqS0N_jh=cnEthK~C&2yv=(cdCxP6i89mR zRQ;7CdA)QpBNbcIs#?}B8JqKXmYEE8TRbaE#=L(FVfJ}{H1Nt?@5fFg%P*Cz&a@%F z#YOnkVQycC0KBjQe7DW*6bwmZ_&fgelW{(fl`0&Zr1}TLo$$AD@c)Z*dq*J(FtX0= zExY7krW+%hI~T+AUNqaC%}OW8ox4|MJK$yqp$<;h_`KY?52Y?HC@S;;mEC!)+;adS zUhL2WPGO&!ry?XF;wI`Ov3+Lzl7dG$VNKXb9qGjujRgxQg>4!uM@req7Q$Zh*zvLQ zD4S~|^GK5;ywVY7$DqA`5(aH%6Vv3Kc=pATCPxF)qQ}Wk!8$SyT-)=#} ziF+(?$z0!)RgagGO9G~~;hp4&cOeJ>!{kaE-chi|oH5C8q=`#@9Kn0zr$7Ep`@}P6 zNG?UMIf`dB&p^A2Rxy8j!-5Z~^pXcfa*R;{oj4TdJtt++w>L^GaBHz*ebjUVq>dY; zKdiIzhYl5UbFA0_Ua?*d6{BE{*(>Mn0nsuYeFZZEhJN3{zK_@``5mu##l;H#os#Vw zR^Mw${A}a@g4ijUh1oqE`n>7LuNL2qM}GeY#7;+HhZhv)MnGXM3fBpB(^FaZJ8~D+ ze}X*R+jqwOLm`xvOptvBCm_f^OLr0);dJ98At85e{E~UOUc!-?NSu;eOfHpu?~TL0 zFDA$VJ@1{Qjn&jyn4sxC1tmsTdNGfQ@>tC!Hf^HZ2O8GaPn0vfenT;K?C*As@E9sl zCxZ24Vy+o-Uri78Kn4z{m$I1|@>rikr~(PH_WvE|h%G`d*yj2W_HhPMFm@3sI_#VU zlILRM4UkiiO=wj{v96hNUf|2{#->i0bd{1eDdV}_q9nmK*C(*bOnG97JiBf1csb&z zCj!j%r+#T0JQS=k=fU6h%bA0M=cWqlVau@TcMx{y|37IrCJEKhoe+IBNjTCk`7RVy z2?zBu4J()gPV`as^dxy*+5wy}*b%aWko_R0W~}$tlN>)GA0A!_x$_q+UQoDT$>Jnj zj8U=DQ#i8#JwQ`2*BI{wES)`B?&K7m&nb_dp2Eq+h%hd9(GujARnSqWg}WWOtqRAx zU?PP+tSZ3BQwb7ZWCUG0S8*((4t}+(!2{?W=-I zd4R=d%V8tv8_1{9?Z0BigHYFZBuU8{#9Tj|y_qeK=~-GD zD=5eRptxCi{Qv`NNd}qKv$83HwiG)w2b{e1vHkPc}|tnaHckWDqM3| z$y9meh+)4vG$xu?VT(QCRSYAw5TiG5PTqBOIPXS)x&B?e4=ZP5`P(#2E=~=HpXH+v zG|uu7H8JlbI@ivf83xeMV`fJq_)$&tzldp-=ka6{a%8`*yghg2q^NK?$JXb_gEWt_ z13BR7O=I8Z$Pctv%Q~;dh-clVBM8@Nr^^{p2YEHlE2)>M?sdv&ZeQL~uNdX9(X^zjtjy4?OJs)PR5_JenwCRahoquH zBPH+uv-UZ6z7^q9N(s##Dr4#kL)V@4(>fPc*ZxL_EQxP-l1hZ&67MY|@kBQ<^U9_>qDAI(=6*?at!Dp*6M@9&g-WZ5_(!=Y%|;c<;fDxlLSY&+9l5ks z`lyxvS?A;QO~~VToNq;7IR!Y^q5pwr7M=|^B81!eD52r!2%(N}zJrd&zL7%JPZ7cn z#DD57=z{Elh6hT&rW||sygE^ZEHYK}bPNJ$7fVSM-GZsEv6fEl5jS^HHdghiHImn$ zKp3rP49Z@Z-itJ;R7I+ru?}9&Vx*7)1{Q>!`crJ$00(cjT`TI@_6$)cR(M4Uu+VQx zWSOB3eqs=uGvRb$>7(F04`(WzYuIz69DKR&EbbeSDf<0OT@p9pab1$C*3t$p#geD8tcoRr=ZK#Eejo_KqiMaD&@3_|Wk!1HECKr?A$Ec(nPtrp z1A;D&LjA(I`|YOcQa(z3keW;th_(~ZP< zy_U9fxn9emJx;bdVwrQH*RqCfg6H2<#k%~Hs@T=Jn8k5Dm$rXXZ0TmB*fRJjv0eMP zAaoTp4m~^6s-tps7n(ugC4KJ9d4WvxrjsYz`jqHuR&@FJDbcLx!nzN&7ab!OW@f3{ zF5*1+soE|*=0Wu&j&W5NL!7-u)y0(S;OH2+bZ)ky?$V;4AdbnfRd?}ZA5b)^&day+ ztU51S)1hI;)m_-KVfHOa6-IN~&V#))4EkwY%f*vrrHd}P$Cg?d%*ACR1(&C-?(gA# zfM?Htz;FV#{hi^IzS@N0G~qXUOaB*@%+5n!=AV?z{&R*CDb&C6IKP?vKf`ct>{1xc z^4(A=!}s}@uz1g|%okgWfdG{Nl+8@@MfZMGzfi7;n7c4_W_ISnWh$qkW*|;8$jWJY z{BPnkEt+Vpv5}dgZ~HhfQsN9m;`C21G=lEOM2U?Y9mq^$orHsU7|Lz@Kle2n#2 zz7npt$VVHO#{`*LJg(}fmh z(K1Mo#$-gyNaxH%W|~FFpvo(TF0%3p(?qDeMP|&3uxQ6=gDKj`jO^5fP_SDB`CrwJ z`(zQ=N+7Ald9t4<3WZNN_a%HjI|5fI>*L^|>u1r3vuMe&N!g;6ZRBN}mE%0w?rhP; zyF72CU@s;nrY_A6Pg#Uf3_tp}mz~Lm0^Pt>RxUzb%U4_7$@rd)=ODOB?Tmjf#_TC+ z%2m=2MFu@h3abE zVazb!g;;{e;bUyx133t=fq0JLAu;AQU~wNs2>SO?($9d8M7$102od;h1Wt22!ANlW zCwRlJ^f}V#YgvBRRJ#=;CZ3jw5iSeoE=~>4oIfKILJT&nV3}gE=+=%}We;Y%eXUI9 zaW&TW7mG7(#Fk$tIr#Okh%H}O)T)srZXXh)u++t==_4~TQWsiDomm=$o_o4HHZnNZ`s z%>0*Qm4FKu!+duaVw=ryQkm3UJVg^p+#+!nw=<82EpV}QZbA{JyuqK`H^H*d3EB7f zeG{D~bjlkzCCB|;jp2lilFGDC5!?<|D&gBB#}$4wjZ+j@!r*7{sNk_pNZ_j+{;mQv34eHNM6}1Fdp1;*e{QR*olmT!06y4DBZH zv}3^X;+CHz@_e6lTPe2Dc(T})P@~8Lie=7Uh;YypVEHS>X+EttnDh0NM$W(zgKFrm z!N4A_6np!8vaIhl>j728X*D1TJ=d2Dg6*rxTaqj38aZ@EG9 zU?+Jh9mQ1~C*(D3f3DarF_dDu=s_OW2mi6ecncK? z+4G?Tz>4F9Jc9g0e&O~3m@Bg+>5o{|N}v{!YpN*8YSwO*7}V~qXU$3CSX-Yexy=q* zQfXK(6gE?u`Z&v4CHi#qKs^~w<=5C5?3G2HR8-~N$+Tu;FQ+;q8(3ogm6fj&y*w|Y zI&k!_TA_ufsLtVelwDtio>0Uzt3~hJquZe%x(fej``%t&LNVa$gsegC0GN$95>Ucv zc!y33IgjhTt1FKov+|9Pk#H7J!c~+Iynz8#EPJ`93hP9$Zs%iBfqN*Up@s`6+)q5c zTHxg_g02lTZ)6iH&6?NeKrit95kTDa=4?(f14#mWfrD2% zQISpkkrAvG!SDr&g*q}EzHiDKE+B(iYNUF3Ezm9PU4kHJLV16CK_IPi`c9(6^!Qg@ zGp+(rx4CXXKLB)6iQtPs6A&}*1Y+;yiv^meS;!iY-a3}CM(p}T_Ph6O4PjPW?~;?} z!i!&*v33_IOg{S#oNIT}XEpz%sghj5Kljq-+x)YfK3`_PtPwq0n+|YJ$Ms}umCM%~ zX^W25e3!9y1=v6-VetiGCtV(fc3OIxb%=5bK2U%~#za1w6?1}ELRpHZJU#u)PaNTD6j>3IU*yYU>ua~qEXU{Lf} zpY%}K8iYa#o%`GO(tT597Wcc2J-|#ji|Gt{tz5y1*NWwBCv(4xN{v=lQl4s+PV+V# z)ivwbv~^;?F1t6IyB-?R#q|7X&TjN-({8K5&e|`QAs-m0h&^mFj>uUfNa>!i| zLfOii6^cV!B->!dv9X2X2)_q!+fc(>NQGGHpbseN0c>BP_@-tKn^+|N*kdZ{Fu}04 zIi)go9$jj7?z&CT49HEed?GJ4QqXL+U_CaSZm^B(#dzHh+z&?H-X}j8d0Q{e&E+;# z_4{x?18)8zQb-GeSgPD`C_CRodz=ULHp9&sr1wY$Sbun1K_+5J>uW{6j>Slh{55Xp zFe6v0$V5(QL#)ULROHd}+cwz6DmGDET7(t5z#Mg+4f1pqnP@UCPC;e?8^i^;()#%g zI6r!yeY`;&;l8{C`NFNLT2fNNP^pt2ym_B}{zh|;j=#PMFS;{kZ3!ZgC%g{l+RgMi zihn{n6JVuaY%xv|>||-hVr$>F+pQEJOPi=MPRL(Fmr(wT?J5@A^qYaktqcYhMoN%c zdpN;yiTu-1@1%&>xDg%uL;Ne=O2h&tx1Rl8EOya#=AjzpL+G10Udp;{6j%87CG6je zc^Nv>_Ye3k-lT?npPk$Yv925Yb)(o%*ZT!ZwoyKSu324E&iXxzZOO0Lv}eV!fq8kM zIMoa4q5fIA!(0l|NNg-F=Ihqw?838{tj%E!&x-B54gp6#^WJ?^b~{5sIgNg&2=XE8 zT_Sc5&%n2`3NCML*6Nd+!22g$#)j-F@!5(1ErxsTQ(VqeP7{l3&=fv(BS61?zIC#L9C@oAC z+>p=U!*D(fb!^C^`k5&EBKvn;(U-W958gHN%Bd9^TKKBc{fJCINW^-K!JY2L0u{Ey1wQ6}H$%lDy8a-|7ON4rIhnDB zs8~ejALQ9$eF-dxvBYrkBURZk32fSC@oi0{(Rm9t7xZy2Q=TgnCV2>rUtP16joB*p z)?LBkl+vO^?PFQVR!rqjvHe@cj!t#(gJF|zwu)gIcNW0JHr;1{^%+i~u9cep9RtnX zUeVM~U3cE$Lu%Y~r8} zcvsih?M9T}!Tg!w4twsdgFCY;6}Puc#iE{?&1(4%_GYOV0#owemx`l?4Tl%b1Jlx2JJ80sPMT$IgSv1cv)?Yp=_X@4g1Tf87z!Uo zwu@exVQk5Ev2|c`tm+r8Ekqi{Tl4TAoZ!-GWPI%!I4bq<#SN1c+r@BDdgFGn)6hS6 zpsF~(;+$z3Ng``GRgdSNd?=5hPxVf!g#I|Crrb&ODx3a-80cJzSfSC41mvl#WF^SEZH-h4EPQN7#j z5a+ezJg7Gsn7T__YJ&1j{L+mx8E*Grr9sHx-i;?v*DxRBeC<}@Pb;F`iXvA!~ zR0<(~dDGHz)YW-mvRU_?V0QUz!cH*_^XHFuicj}R!4>h0Nou)HO$@vmF+mN%6 zoF(Lh@vi#HQgW_h=`Vu1quGuZ#i)7rk&q?*q&oTKZGWK=YtagKNu`|f=>U=6LJhHq zqPSoUc%@tok|{1IA-0KHf&~ojrmZ`b362Btf^y{T@TjgSW$`bG&uNyj>n}lZ?>XkO zOPr?9-AlBiDwGy+HZqf~-X#{2VZ1Vwb_?rU28JEOCYFfB)isDe)iv+4o-c!mrW&WdEZS>y>F*FmmAv#t@&pmTA`bKKxeTrH z^HQ|R3AsIe-@vjKb=*Apl-|QAA zYC_q7SH*Uo2?tQeYf)kd+c>DvP%(u7IV|f{>?V4%!dJzl39#=gfA;~B!=3_pMaT^b+3v2 z^=ElhD)wNGt!JOVCT8R&y=%rcIR@Bni%x+@bkEkQH!Asr} zFLen*9on>YA)Ky}OaFGp;1KoUtUBGZlT$qxvh}$OM>QS`(*HWm3kC`ldg#dPD zFP8L4MQY$V*|k03DX281&V<>R2Xl#d?KHe$A!G1 z^cY}S70dJSOP_d~(@MRsn#I2poHw*z8W z$O}(l)Z_PwlaTuf*b+o!(j)x>V>C>)7KLG5P&JG6>R~?e%fp|gad0Txb3ptH@x1n~ znBh^MhIk4{#IHPEg#!eitZzO-e#O}Jpg2?G@yr~H=lSDi&#vs1_rws7u2#Q`7QZX3 z{ylMs$K~0UaMvt;>sZwLVv=S)>-D~Q&N^0z(V7>SYXwq|W%+P<46|Z7oG_Q~Cw7DU zZqBsC;%xCNF%JDeY_9P!P$gqZ;xJH-LkSA5E_V!>TEEg!h5~RUrj$u+c_sFZ-)F2+ zT$Sd;c4C-8RBs zs3WC&8#f#hKi6PlH|?S_Q}DYAH53&UcAFG%YvDX|{#f+$ zO1KW+k+V`Wvggj8o4Qc(^$~Wn(2ud$e)`TopR!K;;h%;>ov^ePB}<)Uj%72PZb^$$ z6Vv7{Qgfgl(>?|t*YT;@BNjm~IVC4Oo5MW>`R9>>j?ReiLW_znkSA2iZhkCwoJ7a8 z3&UVhNu?@45T^2;nR82xtZaq#2JxmxtfwWd}|;V)rf z6RDNOG)ZV30-tm!r7TRSh_eQ%pdc@+K?rWmTcQ#q4|P7FBEcHuG6l(0gCrbpV;iQe z5{6cX$`TPo-oTDji)|>6-1hAVD#-0j6vTOzp&u{beUxt+fzJ@Q?~4Tlh$6rt0E(Q~ zhQ{W6^jK+LCe)<*B7JFD(>xbhJZK`G*GP?=*V&FuJ0=e5-K2CugsCs(Xk3T+E7*8` zEH+q6KPE2G#eGigT_=|=r>4eo)^Y61?_qO~i!p6;7lAOY$~P7xwrZ>;O|34$)`!)I zcM;T60?U*zjfjrcN%-^Q!!Gn;RJPCSzB(lgh=tG(cv@fk4&N> zQER19ZEk`{XK>gfH(QHE*E(IX5!}GqOE^jvP(u3dS<%Z%4;-GX1m$t@B1g0Jr^PNU zo5T-m)~ChAUB1LHX;~ar`mLPvG0cOb`D|+#CTY)z14lN2bt8GvVYO{dCLp({NejpR z2GR45ow6({s+ zlB3^AhHRQ6uY#sIa%Y-zqKDs^bjW!>(4BplLaL1831zdiIqP#y95LBkTf7FxAYy~Q z+@PG8`3o21THAsn^e`jP$u0RB5JLJ<*Vk=6YRI2Xg>PHBMsyrlQXCiPf)kX^@+hzr z9INz8z$Il4HlrAi0S3y?V^!}{*6efWKI4j;&qY7S^ci3$Y}DtX_ps6UoFpgiq{YBx zj`DCg4f;TvUeB$qcjn;d47j(({xjYIV<{)Dtm<>|v#=(0HZTR`Iiy@yOqa;!tuP5W z!B#@$mF58q+(5t!#I2z?rm!<#i2mVC;`wU&V^}8$uqlWtbzE|hzT$qQizeGEe`p%j z=t`a8oWVWqIO}-hi{c2+?KhNhXxw~|7r?Q2b2}s##eHoluNI&?AT52v>Mx1y2YoP=>ic8tNAmi96Hc_Q{_zTbp5V6Zcoj?dQk<513&SWa zzE?spRl3kWi8+l^C_m<_hd8rqyMlKJto9ZwXSf>UC?<6+f2SonzWt-3ypf2t=DbMc zrjgw zgACeGDreh$38vqU8w0Ea7Qps@CAvp{oq(t=Mc5{Il0Zi}$eiFo0=)weX3+8Xj@-0c zb(0JVt@@Mx zD{@$0^D$y7PWnYHyq@x+7|ve1EOzx15Q?(-^N||6{G0wqZrWS2d56_r z7QF_Xo&@v@Th!bfhU@X%yh*UfaP}Ahn z9qwgSZOy*}k%y>13ezvk03yFZkzOvix^lo_h}&G)`x%I%siO}K;Vj3Pj02R#iNTQL znmZn(ogvLQR6y1Uey;MYB_r{OnDWUm##PsBVF_2o7|md|?W#Dl7vEKzH?;v5TcYzH zXjVoqxm9+9snP|>awpvw8ESU2?$^Y2{!JJ~_7lje!)hz*!=+}|#Ev0D2)>1mkga;4 zQezha73>AbOrM^B$ZeiiDMExR0g1A6*Dw=0!yLX516`2VMET?uT(s;MssWQ*-U8fN|4DB>3DobC1a*GT2@m1P8 zkx#;1T~o#)Zir7egII9FG37Wrenae{IHn(G_iiYHs;pmtD&-cudPnuS`qbkS*JU8r z$2j_n3pqy*AD#30Q$oe#qH3Pv3!lej)!7ywRak9<5!Iawt8t3gNk{WUg(f-d^PAX< zy}>lM#CFbaqdQ}&eEML39L9Ry65TZzEN_W@MbBAE*Zi8Tz9o)#xrucQ>PYraQVn2; zy>knT{?r#N6B8r&AtojX70Cdr(xewwhWNyrX4G65w4fIfy1q2F;EUx^VaS4Y{=z2| zbIDtsm+)C{G6$?O45jFmTV5PVX2IoB-(k1*ID79qv0G@}7@mp8S?d)7+s^$@0RRyb z7oD2R!1>C47I0hi$lVTKlLIEVHpN?Oj@cqn^HDAn;1GxHE4wv8p7_tmVE`97Y>(op z%H@zhLh4pv*W4xMv{;t41;T{Ni?myci`Tx1Cq$mEru$AN@__Ghc7iEvSd$jjq zYkJH}NUm4*Up<72?EDX+dq-J_weFXA2%R;tf-Wv)QFheAl=_{$jEWOO893OO2@aJQW5%i#*VZ1S(+8W+64A-%e_niIjt#z z=ce8_*~sgY$ooWumnj%b?>O}TvDfk@(y-9sE2t$3H-aZToV`{fX2H&r=a1r0AAWJM zA#WF$yFC5nKTSt&*cUs5V#*oLGJb?a1d3hmYlz%!2*nN1Sw!gkD&NT6Cqtb{tSH;X ziGMf#cRR1!U<88?D@xi00oo9`2O8K#34KYSi{1QD^cn*sAv>TrvgCu)f0Az44glnD zC!(-PC0G`ssN?PqF!dvNaeN_^QSd=Jw}&CCnQ{u#C|Ggi24%g#o5kGaENlKC-U?n zj)0wTT!!>DL?Y|@{AF$E4|(+zD%BH@;h$^g{RDHw4($F<7_OdS9e>6EU5Ft&bbW*! zM*QB$>SaE=194z6)5fA4E`R!2^qS@k_GLJq|D!!W4}z(pJcm%B&E|)WB}YNv%J$*6 zss+LgD^0-!9{+iRsir;j-6+79Bp6W?NQlQG&*D)u$cNaSpT&Tf&oCw68FDxuBrPO^ z9&#bVbc?Kig-9TODE-Isf#XuV*SpjIyx*w&hCIHO0>YU^U>5(2*l`%)W_LV^s#De# zPdXBL(h6e*Q5Gh9@{8l{n`&-?K8ho+C7{@0+{h}Wo51$}BDNmh8^y9T+xUW!#PjV{F+gge*qD|#%1HPyzCml=Fud;M}$j{GuXnL$O z24WCFXKXHG5jSrrYUg|%I8HKas1yA~$}iQ#85Z!X=-nDoP#(*X4O32)n#W^G9<^-3 zui|tn#tNsR*3@-E`ca19;_r~wl&O{QqjyL@${1Yy9X=*!Uz92ScFtDn#|&()jF7tV zvW32~8Q*1u-;EbB^p#S4Q@fUOqZDaWsYw-OlxDj88#J0tITdMz9D1;f@*sc1fd|tz zb6`1-T|UKuefFds;=tWyrN>#>Z=##eUbMR* ziS7|!JoO>w3iv2UL^Y=$XJ>yCJ5!B>I8qGDe=$`5(LI~HsRYZf^N8)MW48VA@D*Yf zh!cE6aqq<^r(H7nfwNj;x|&RBr+C^s$_QD$@;sGvhnoM=G72Fd~%WqCW4zm!T8|PA=H!QPPXjpB41O(RuYA^NE$gv!?1@mqqmIe@Mzsuk{z&0i+q%$S`?Rj+3o8eud42%zRpe$2MnPQe2g-(&H_+-&5n zsm28owyh={k`Nc3X?W=O0=b)Z?0?g*|L;^meFJr*He2UMVwmR*xF0vpStrG^Rbxf> zFhPr{PqL~x)*=y_71?t$<}4!RF?()~jk+tfatSp>v!)o-T6%W*kvK1RBH}T(^l96c zo(_-dn$=kSF}E~%YpN>%xBUgSh!yra#|q!zpjNpiDc;s0&vCT9KY1s&>0Y3VIh zQWviXI9<3sJ{!%SRze)?>`Gn%r1N6#vY50|eK&JTB)cbzs4ettkVfjCTL7@R9WUCp z;|6$C*Gw2}ZAbFfRNn^N_BUM@D_m|FEBN9~zev2D|J#oLhS53*qftj{kFB+nLOj;M z-Eu~DhRvYtCTwOy?ImA-a}!c?QeD%~866g$nX#B!LeG}iOGAcz0uOU5UbAh*^YEyy zX*JN=isY@SruhOIN$ArfSg2*c+Do3Ubn_(r=&p`Ec{RBpsOkHZvj=PWX$t>1IGpKEG0}|b~8`w?f|3`w#7m6&n;Kr{b}8peiT>Q zz!8?Xyj-oc<=hJKgkmJXTkfX7{~8`E?8Y9#f5s#Jwhopn1pEe5w(137rI614_u354 zjpjE}hPI3rcDcfutP9L{ZjTfO;JcrZe-|bAeGhY= z{?S4s?C$=%L0qx2h7|!}AnG~+AJm-FC8(*n#10f@;e!CjoN=ia5N_bT0q~)%E#<@2k4Ilub>{d@EUrS~c;L`zGA?xy z)D1m_k|Z!GvtC_h&Z1P(b@zn*&=CQWN2fzmLHV}6Nm;H!=O@)T!WX9EMi*E;V=DtB zZ->2WVg=TEiOw^(m2eT?+Ngz@^Aj_9${s?@I!Lby#G+I0Asl=RN>|G0g|tEttqpEc zmb*|0Sj(m=`EEi)5lT2IGjsmP45iR|VQ*1vuF!&DIJjX325dltq=j!ux|I-Af-G8K zbajn>yDb)F#a(E42gza>hGC&47>N@zGt+f~!@C%zld_c9U4?o$C8{?SkSkn12uNJ& zY&8R|gj4S!v2kuY=K5lMCDrLx0D81l(2t`19LY;J>njJ5UIK$gXp6+`-g&*`&smw|| z)O7RON#41g&mp?_lT&fkY^b!E1=&4||60)u! zuL)SKRnu@2Vy>Z)6ctzn$wkoLh!w+3EYy48dbD3FhE8$dSwc1wNNRzd^5wfq(eB{_E??mGmD$()~>1-(%P=p|fZ zZ?~5`Cp*iim9Wg5j9KRUid+PTpOC%8OtpdCgduP{hh^eQ+4)LnS0Ni9-om|kPFo3k z0Z>|4fq258u79B95gqVztk5cAZpxg@jFfaMmADI2;L(z|DrR%$T;&1iYR-N~Lb)bKh2}Go3WvBT}5~>X(B+_LZbGJ)J2Otgj&FK<``6)JGd1}7{xKkUSj4#GAraKzDmr;uP zFvYAE&qr|3j}qKQW-LOXn~kIwt(H$k92|Mn9`iLcQN?GJBEC+Hc)%3WHwCN($cSDBY zp+w*-B=i_1=;<5^)VXKbc6NXCwT+#mHn=_#FE4(%S8E}n&nUrz?e8S%rzU0j2s_|( zLu`+e9>k%@QGzpkEY#;N)JCBIlvMP>xwFjlCw}M1a+kS()=;=2Y#W9zwu)L@*APvlpi#Pf7$nLKUEH3Y17< zd}^-Rkgme%3252zDT^%(F*F5rMSu|&M!RDMaK_+L7juS^mmou+@@Q;%nPKu$z_6z^ zA6-s?c?#2)A(NcC`R4di{H}N!)EL~tML$$8 z1U!SJRF!@uu$#~qFy|=Z?CLP&Cgc%le0t^*Gsp)^OmST$Z=cKXA%diCZ9|algc~fk ztJF4V?@9`py1+s&dLc0nX%dKTUgiJ%h0Uu*30~}`yX3~Mca@qsc;zFHE>G#aF%V42 ziW6GG4teTAOMSE#yk3eESkF9NYkNPzg$?T_`Sy!h0}7%-HyIXjaoyTcg8PVBN-t>Q z=P$@?V>hXd-JzG*zHU;0-NBdH`ED48s@_2CPcG7V4e%5Cz7;39Q!9q&EL@0l7gnC* zDU`k)htnARR=dbq>8Xo3H^5nqw^>M#H?+J)A8QbHGIBnq`I#IGD=L1xfAwvX8_GZsX@?W@dxI@pC5T zgzAs5mfa<9yWnH2OLr+C*Wox~P0CVul&g>kCzoo>fZYV3vAK^rb=QHAE}HUoDP&^&T0wdOB)T|&YO;&tAGT!p>(maM!%FO+_X^2gD@XYR=^ zLiy!58`J#$Lc?X&&;w(5;FUPRd0e8E+TDa51d2#mIM3Xj^g;zdYK&^H(+L*=LqjRq zgeda0+E8YI%T=|Z`l=084uH~73IrnIwNY`jLcAz7d(7}h;4<=H`w)_lE3GW8^}G)EwFqAuDoawhL4-5tQJu^ zPX{ld?t2y-j5&qA1}!iyGaH@ODj~NN{O-mH%~Dc$j(voIKe742l9%tA`*9e5K|Iu& z)^Q|2sJqX01*3;1{K={i>l29&fJm|+@@^w%>xEeli6qhcE#%}SoC3_%JhWQiE<#Wv znrd{fUco#UZG_}T*1ebH*XI=AJQpMb#HB35`6{w)>?O$XaHZ@)FtEZQR{zD8_maH& zb^a?(@I-x4&ZBcsf9Vj}Ri=*%E#ccTCMA8gRS;_}GzhrhPx5uBvx^s)Zl12K14cAQ z)}puM=@aS{FSyQ#!5R@v+3*o!oY=75lGl?7@Nb2&`6&=RUrAD0RWD43M~fL) zm>^k;=iN=H*ToCY1RIx=!9l*Tr4kR}fJ-}6V}PpTo4*j@itOyo(0Mxr3J2+X$Ru5x zI9H*hRXir0h*e3djS%1#FL*+@7_n$XdRAHr9U-&OinkD~M-I6Mr!2F`-A+h%XT$n{ z)1G!`)9Ib9{E2V04tguMfq!GuqCeYebV*g>wax&B5V9ZDzRO&@NKgyd<38 zc|m8?Xs?7WG&i3~ql=$+!z8iG*l=OssBmF=S~#8KrnQh}BF^c~&7dwoOC`$LG%UnO zb8$3{Z@BMb+xsFv7hM&_lK~^l>q6KKl+Wt0F<4h{e`WZG&{3cbM;o1yn~(09!q-D* zM1JM&JrgV#HOlu9iw(xdgfXcw(aQv_lB0@NiLQl>R>?4=M&Vv_a;9Cv-E2fZ$lMi#I#nPipP+y31p+oN!lS8O`kbOZ{?_ z!XAqyT8-sdE#;-y5i4NV4T?!QoM#xTD$2G+w6r_MXCQ!KzL1 z1|@Gk%x#`O}yjiJcj zMD5Xqu8mx)PYyw52)qg4f~uA6=zATZBsIoZb?9Ghyk`o{TW)8XlJlWrK=BVmNE>AO ziL;7a(k37|%H&2st7|r}i36k#!L8Js-L&QmD9(udt_DgnD}9=#(Vp!aAbECth6o1c z{~F~~H3^=AtftT?QVI{)-2sxHSkzJ}`!eP-Q0g#x9vV-%tCmPjZiFwCDk@4MP#2pJ zZ9!G;Wke0#2520t2eNgC4=7}#h?XbiLY@R{@C}r@=6;9lQuQv6G*>V1D0c^dRZ~DD zO-aC4cBY(@7E6NRvyohhmnyRrrzgR{K}_W*8* zgc=5H98PMGC)~MblIMSS5A<0te}wGVbdR+N$d#_Fxmbtvpn>%4Y^-xy%9oG)S;|+? zoT~6iwsw#d7;G11Emxz#JqU`hawQP>{UxyV)mZ5T4Ec3{isKt9gW1=Eq&9jHFceg= z+hb}*@m*oggQfVEEuziw!2sl7HfJz6!xCy2U}Qh_aF$wQ=>11?cg zP$qMym1g-5mFyZ~EoIHG!m4IyNd6(bvfCH&cclyaZHUy*hle?ZzG!$frogm(Xmp?Z z`Hv{U5;kI}i2g5t*-fw*$tQGYf@O&a7o`WuAW%B zLm&BdP@-7_Z2*9iCdxy45|QFaQz!Q3aA^`2voNyY>4j$$o>V-!M(Qj*i4eo~`q1DpLit(@x1f(kUbFE;UKMa$8aJ2)x z$l<`MN2*5uZ^rB4lE23LK|-vscq|sT@N~p87|&=tGni+jv|Z!R4n#`rH4oXBky2o* zFMmR5$jI>4f3>K&9 z1nu00d#JNHY~@Il@+meaR{9>cxkitYd?V(_l<7eGh(KpmL&jWx@$iuo+pD!Vobb5) zln}cdclFCBTT5T;?NQQmn&;W@I1u|{HaSl6>oM^M%I}ly)ZnpjT7vs3Uxrp8NsX|T zOfkF~Csk+`v1##A7tKgk7%#PU>-POUQ{Ex_9kk}3GX?{T#~Z97Uh1UzmEDM!p3&s6 zDWj#SFmYTtTJq5}vP+|-IKOvpBc09p>DU<{=36Zvjza%>)Ep#@4W}`ZpJoZ0G)D3b znheBZhg?HaZPDiZ5}+$c5fna225hqh7R<`VNb_Jjt3`q|M>B=xBuIlbZCQDO)JyXV zyOkhy)SP1CSZTan)~jsVSoDk0EPt$&t+8VbW2Gr=NotbEKYB>EmD9Yi_>b;{BeL?L zKBV(hmlnu!#(^GAvn}JK_IC1nta6+*OfM3m`RK9fXKFz3z420VbMQ?XCVpe-+CwVy$-(?&@c9Iv+C#=LNqptn$_rS)luJkrI*>Lj}*TKz6!*)u}8K|prqlte4 zhF)8=IuKP(6;`4&B-HYwhzA$*^rloi-q&6vMYBH^ov>^)R32L3q1rVjVk4Y^1B&D2{@g` z>=(>1B^ZaTWBZb%u38ykioz4PmhX2-(lXrJGTrVoF!;0${#idK;n4!rWb9%BAi*Rpom+`Y?X`lv%!W||_eWo{1cFTXHx^_V= zmu(;xB*+i`#4XNSn%h8105K?#8`u$*kKKD*O*Mo1Dj+s$vQ!Y1^^%=c z$?4BIAngLmu3{h36Fr@@@9skUsII9oHcpn>J7}0OV7jzbLt{;f)V?LyamYa3nj@e@ zs5mn@MT$fn_m~0Blgz4SNE0>TMxU8dkw)T}+5HLY?OD=Uz?Y{=!!)7gOHp|>-`q2O z%%=xQ7b`f#?IzfBWLL-_VeJMK1y*XV0Ut6RM(z~B;;BniM-j%dbZN8(6;L-{YKs!K$^c`;dvK;S zRs(w&8?q$tN!_YZ0*A#oSL)n^$+-azpi2`j_vk1G>H#bz?wL=Ur~H%-KUIF6ydCx^ zT=ENM%93XGnzkZVII=QU*ogOAcuwKDgU1dqe>_9*OvJMYPcfd?jhhxoziRyAswiKf zHu);n56gc*Ou84_wMZi4gB6RUXJU7LjBy>Onf3A?pIQg@br$GN8|VT+G2AbPn97Iy z6u2$XCK^{{OH~@XO&_tFizQDsVX@>*!oy-|P^(TKp=4|LkdbeqJb17V7lVmom{}}+ z&Cd(8lKW=jYC~1CK0gt{3mnFaOQakPtb4~U11*j)mMoK|+i7kXe|-i#K}08-efXS7 z_F;=wNFD5waX-NdX`lssfL$eU-8g2qQtCNr)p`qKMMo$@105zUg5s%-kfqnV$xDdp z$Z&Ck9Cre&dvwkZG(&BWKLx6pZ>AL@7LvWW2$~0<>Y7Q+uu}3Bf8^{HNB`J6D;-sfaLEH0q$9- zuB;%}WwYxPxjr?!u954I*;P-jeP)-#2Do;SOQLAJ$oV{bC0BY$BO1f=z+N>|*_u_- zIb05rxLQgFtshw}g==&!*oLO*%0)CI?ptMUYouXze{N$Dc~V=Jy+(S&&OV#@7f6F# zmhR(Z2bq>jpJ!NFfmGb`*_WvU@2-$BA(K}d?bkxQMZaphPU_#kd)Ylx%pdb>(OvKM zzvAe;9csDpdoFiy!N=9e+HXIRqqkw~nt^`_M;iP?jwWY2$`P!1ofJTV**eLyi*_%O zaO5?6*dCr~v=Z^}Z*g*M0PExA`W^duofHJ&%(qYq3RqT(XgA}ZHQL1pV5n32A4Ir9 zh=x(jP>7T|u)T#+*N_Kq@{}&iN$*>exuXED$)PsD^8li&T)LyCUBz6Br1wzhlSR@c zymqdaJ{-Pu4^iA@%Q@6Eaz|b>ONSHTl&60OSVMtHS9A_6RgMI#<~Y8H^)iF>8!Wf3 z-yr$S4|<(vt#;cVkL)9_$*T@nGw2F0P-(+$o0;n4e`~#nRh)0c}SoYIq-MevpXf7PH?d zh2f&jsEyJ(l>h8Th;(V}-bU$J&2m=otTf)EWEbf1942+9oMV`qD6@B5XZkE3h5D9o zDPUg-@nUwqL>huui|06J?)jY5-wsmz>`l^iKu>Oxp6c=hVk?e3sN~_q+aSwG_2j_^ z+;KxL#vAu$8YgX*cG|VNvIC{qY#^ytApppm3}V3@V;GYfG#VV6+J?Rm&T_X&J&5wQ zNd+*G-gmn+Z16@9pdqqc_PK2Wo!>6bpAPP2bJNK__!md+O|XIt97RrId$&U#$uXYZ zE@e`e7_tKbFAgg2ASuPTafkGRM)NxB`Xcr`3)#pQrDK|E*77A}YrQf0C26xpU%Quz zxmPKsANmr%40D(C8EoW!SSF3atJ%v^wD-c5prvB`>*5gTjk~~;Cyh%mRBw|%WpiEz zePcfGvJ^)W{>xwkA2N?uq{J?>p;uC`J{$3V4NnE0+bYcBHg0-F`rb}cXnguLX{e*- zva#YVG^-}f81pvTT+^8u_DOwEo{#r|nKuuH{s+{-26ELdHntpP`-ElT)jNzNtrK~9 zv~E)t%3Wm9q}J-ptKgoxHD^FuKw(wolKv?LGp{+Zm%#K#XoGrl@I2DkmUSFhX904n zNDt-_W~~Lt&mY|3K-mH$&0+aG2i^vd4cjkG(S)%V_DgMMtI4h*ly$q%V_=P2JzN`v zGRi%{_HekC47I1h+i;!^)DGqcYI)&ALlK3wT8}!h3Rtinm2<;tDe3_8KOl9(sh?2? zq@ea{l1mXR!IH=2a69sdyn&@9Dq##F zg>Inn!n@M@cA7D4{rl1r=+(F0mttK5Uch8Ny6?)RhIL#Db74b`lCSU50`ULUXi0Pvb+nrKFBc{XlB#d=~k|qGSs|s@eJvkgeV9)(29u=Cm=SQnIu2n}GN& zN2@9es8sdxM!flg=OO7;%rH%dq!>-n>oFfm8U!DCSn6bvE%a>JVMvD&?9^c}vIyfZ zhozkwyU_k@V->nnJN8bM)J|h!UsOp@f;SF5f@Opezh$B5=zA7^f0Fi*yTzF%Gh_DVe`AR+ytSx*>TLI(plInp^s@nyq+(C7zHvXkbd{ zgftwfRi2On2mO{#sVz2aP*%RMD!CjwTk;<(kPzr1pIi9(XwO5mNrS;ad8yn$2wyVK zlTv^EGMvO||qvYzbhDd`hUim~() zslUCQ-5hrQG}svo0iBkj?4EUC1I|btbZJmGqs6x6*%an!Ht!4;H$siCoq>Q1u2^+e zveRf{PKvPGreWRBgYplu1?MsAIL)@52jz#e3+JW6Zr83Oz9iUVZ;+2- za5d$~Y4rp$uVma=ghFy7YA$T;=h8L}j?RA}4YHqS(io?F0jkx1$kA^omK5UA_BhjN zJbVG-JMPoTy@a|O%ywKtO@^~`mmsW_u%9kT3FrgEzLdK8^2HJLxYep#JYjhzs;;^w zg{}Eg%IM6O^(UUr;fd^}8|d!12<*Dl+3vev*>~4LZ!fXlH?X?bhrM_M z%+eWVIi$||uj(|yiF|(a*pMFxvFnwAgN>S-(nY)GpdVsp{n$6(f%t=sjJcsVn#vd0?oNrPGbh?U%tyqrj*S)R=H-N8W6 z!`SS5ED0$iWd$4hgES~$6G9gk#94?BHS4BPqxxVtMe{vfp$J43-ycAI+7 z#LDkV?p<=uD*Ks(fohp8dI876GwLQ%B%d;0S?Z~Im5q|6)=q~gl3bP{O95?PgTE!@ zUfYmUc*y?j9a-vauALlKBSR2$Gq$UdI%~iUZ^Hyi ze>Tg#EBTAR@oZuzjJ5S2l*_D#6pz3i1nzI{IqM~9ko6p z*d)iWq*|$+F28{yZj@7!C{FA?)k=XKzUKuifb|g|} z78^5v!pg9vD#}>x&r(~9a|!eK1zrVZ( zs_$&N852Z06M8Iwt$2Us*o9W%*z!hG~c=r2HD#ID( z<)D49Ir=(vgl~+O9JKKo#NXaY`;(@gxi-`0!u4D;ZJ7SH8--Rcf(RT;p&uE4Xr`4l znjqtOQTvUCW-D54dlE;q+R=8qj~m-LYwhh&hK?<@4OrUq*J;PWwNR&>3D=j3tBZ>k zGCP~$@fsG^&Z98Hj9@^fm&tTm!|ClqZlU5t5AbO0)Wiiz- zqe99M-Hm!r?FKts6kg`7ouIkG8oaf;U>A9t4_r4{osaf{rUg6Zi<+rnvahzU-JbVY z8$VPWtR}S9258=3om*>r*kv3vCb!mNapVr$)<)ZzR!I%5idNIipsW-FWE*YA-UNd< zPcVydv6K3HroyMqnbTN93y%AEOl^Sm zWT7rBCg%{2y*K8(dLsWx9JdgPHwEE^9hhJDYphGZwNR_1R%mETt#F_H;;#)fGmYPw zZ-6!!<&6u_W}y;43ebAC^n<=Fwy>1$mdkDhXnzTM(4Al^4@TYgZ{2PBa z$Uov;T_dx<+G<0Z_eCt2)(ujobxG~CzPJNrK|AdiAgPG<+9=SHp}n?S`(WV7@xgpH z0^34Kx2-b(lMc1f0t*{g+H0Qyeo~;eJ8kp?YCAgdV3XK8fm%!dcF>M# zliVAzc0_(?^*ql7`w#~-^2%c{7&*WgF78xct^1p?6x zMD*qu%rj#p!n}(9@PlZxlZ!U>W-KnP$agwYO+aer$gK>|^L!fp?wNFJRud&9)in)p zkOE*!I=_+3ZRD{hyJ%a?tm}^&OOl&n<^z*NP+!Nk{N$|qV$6QgoGFtxr7o;lqKkA~Tjh{AMwTXBw>Z4NHxQK}vcwSTAP-}@9$H`VHAkgMeT;p2X!H60Nl$GA^3&K;I}mKK zU$FK!d%QdM)wXreB}Gt{s^n)yO0bwE57Y)?BX-3=?Z?{6e&)b}n1l z`ytvNHKnXiXvb~ zHD8Z1%0I(N_D~I+9!5IwbrEh76{abpz@@P|6{QWeduKiKj7EXBvK!Ib4!+S6wO4i^ zi5l5$xTvu^X%tpBD#}?vj5bp91DhSA4em}S4&{kXkYmO`R8z#lm(e0I3B}x@uH0}D zF^W~kXwT|)A|B$T(GB&ej7YX?q;{Iq(^uM`~?$SWXbPBa690hH${5X^X3ZY%~M?9{|+eRU@h z1rbNPHA^6gKTP{@L36Gw{Uex-dv~b?^kg?v(upl&YHLNb;+7^`@Euw5;<2 zz6=G-K295LXXnJ?;F($%jr+Dl4PykDe*e05w~H+X#)oV%SI{7`GumJL+Q(-8{Gb^yNotsVH?djwBY zPzn_kHY{H2(Lw>OQ9&sHH6swBU@PObzMehr*CTWu{EN8>$V!wElUi0DuN~rve8{0t z7MrMCKWWIDMg1a{*^kz?ZPVG|o@s7XDMx?!IF6Qujn;PWD55&#ptJR~d37PFBAk$6 zWX3eHQownR;)3N!7k2BnjMnz**A=+MTL@BIkWKKB08~0~JaX^1mz!}EaugTPY+mlj z9*)*_ZS~og6qF!JA>@{9z!=Ddkt}bF)(@|pW3>ISl5k;+cCa4njV~mX$#}`9{-jzj zt3A%zCTQtq8!(CbLydXz{Pz(iWln1-t*{-qLl*a>L zPhy<5Z7y#qYc$UiPk}{t1`|XRQ7PXT-rJ2xMi<;)o&npBWqlt@_DRAYQc8+lvC${F zNl?_GkW|JMk(9k!ZqK;C60u>+UPQ;!OCXDfq){|Z8{EU3@1HkPzGqRsL)0u>O)AUc zxs;zLJp%}zQ<$SAH*8TV{u^)9QY!gD#td&nibKt`l3?^v%wd5=4 zb@d9X(y%KNwCj3MTey>2i2Uh~^(rU5_ziL499;!(b+2r+O>Sb8&IWc<&^zc&(5Z5eSB7G)uvzKDhNCQ17~i~ z*=w1s?deE4`JII&YX`gGQ>CYj&y+k1?Ac@t0s$9LPk&S^umzdsisFhbe`BMjufcF> zMWL`@6Y}%Vy!LA=(({yQPPUG8hFm@evR2%Ez9=fm1E__XtDnK(;*C)=$#*$gRR? zp%iNiv3HwsUoI{Z3of`oG1k(Uu5Ku(h8ej_6a2LKAWt#V{}*hX(dR`sr|&; zJgvmYxwJKWD!$!w4{UfEV|qrH189A2!{<5a#YYTRBD`muM)~dK70)QqwG*jlts%xj z9>4IIXEDNW#>YO3(LXi;K8pgub70RZ(H@?c_}2vel>hat(wtFk4f`29d$z(1k;L9+>B5Z9%;e1%{(&HdX*80LyOxQu)Q?k}oe3w&K zwKL(i?P_yO{O+8h48Zbe`4lD6B!tzvkRcY=2gk_kgRA!q8{iODyFmEpO_6`}Kwqok zphA-9QFNbE-153nlGxGIGwEn?DeS_V6@2x-l(1*3^;m&OEHf@=++#gd75ai|QZ#W$ z@v%LbN_0hfGFG~4_7PW}Q^G|zD!1K=n{;!)3zy?U{HsO>I{Qf-=*ytgJJ2EMKzE@& zi4Ig7b_;rT+0ZLE_ab^+tZpGnF~XtO4m@Zl@pDSgHuior&Gd+TnoG&r*Ea

    + + +
    + + + + + + + + +

    +

    + +

    + diff --git a/ts.exe b/ts.exe index 6f4a275fc5845541f34e0ba14259d4c03e69c89b..9ff1d091428a594fac7cd7db8375126a3b7ec319 100644 GIT binary patch delta 20599 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 diff --git a/ts.tsc b/ts.tsc index 4c3dd77..7e03538 100644 --- a/ts.tsc +++ b/ts.tsc @@ -1,6 +1,7 @@ TILE STUDIO [Recent Projects] +C:\Documents and Settings\NetYaroze\Desktop\scrolla-yaroze\scrolla.tsp [Window] X=0 From 631efce116d988b3184c836ab4642e7ef94176ab Mon Sep 17 00:00:00 2001 From: Mike MGarcia Date: Tue, 22 Nov 2022 22:32:56 +1100 Subject: [PATCH 9/9] original with no settings original with no settings --- ts.tsc | 2 -- 1 file changed, 2 deletions(-) diff --git a/ts.tsc b/ts.tsc index 7e03538..4bf2f7d 100644 --- a/ts.tsc +++ b/ts.tsc @@ -1,7 +1,6 @@ TILE STUDIO [Recent Projects] -C:\Documents and Settings\NetYaroze\Desktop\scrolla-yaroze\scrolla.tsp [Window] X=0 @@ -12,4 +11,3 @@ H=600 [Settings] Trans=$FF00FF Replace=$FF04FF -