Luxophia

1
unit LUX.Data.Grid.T2;
2

3
interface //#################################################################### ■
4

5
uses LUX,
6
     LUX.Data.Grid,
7
     LUX.Data.Grid.T1;
8

9
type //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【型】
10

11
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
12

13
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
14

15
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TArray2D<_TItem_>
16

17
     IArray2D = interface( IArray1D )
18
     ['{E4ECF85C-317F-4179-BDAE-C4495D2B2CC7}']
19
     {protected}
20
       ///// アクセス
21
       function GetElemsY :Integer;
22
       function GetItemsY :Integer;
23
       procedure SetItemsY( const ItemsY_:Integer );
24
       function GetMargsY :Integer;
25
       procedure SetMargsY( const MargsY_:Integer );
26
       function GetItemsN :Integer;
27
     {public}
28
       ///// プロパティ
29
       property ElemsY :Integer read GetElemsY                ;
30
       property ItemsY :Integer read GetItemsY write SetItemsY;
31
       property MargsY :Integer read GetMargsY write SetMargsY;
32
       property ItemsN :Integer read GetItemsN                ;
33
     end;
34

35
     //-------------------------------------------------------------------------
36

37
     TArray2D<_TItem_> = class( TArray1D<_TItem_>, IArray2D )
38
     public type
39
       _PItem_ = TCoreArray<_TItem_>._PElem_;
40
     private
41
       ///// メソッド
42
       function ElemsI( const X_,Y_:Integer ) :Integer; inline;
43
       function ItemsI( const X_,Y_:Integer ) :Integer; inline;
44
     protected
45
       _ElemsY :Integer;
46
       _ItemsY :Integer;
47
       _MargsY :Integer;
48
       ///// アクセス
49
       function GetElemsN :Integer; override;
50
       function GetElemsY :Integer;
51
       function GetElems( const X_,Y_:Integer ) :_TItem_;
52
       procedure SetElems( const X_,Y_:Integer; const Elem_:_TItem_ );
53
       function GetElemsP( const X_,Y_:Integer ) :_PItem_;
54
       function GetItemsY :Integer;
55
       procedure SetItemsY( const ItemsY_:Integer );
56
       function GetMargsY :Integer;
57
       procedure SetMargsY( const MargsY_:Integer );
58
       function GetItemsN :Integer; override;
59
       function GetItems( const X_,Y_:Integer ) :_TItem_;
60
       procedure SetItems( const X_,Y_:Integer; const Item_:_TItem_ );
61
       function GetItemsP( const X_,Y_:Integer ) :_PItem_;
62
       function GetItem0P :Pointer;
63
       ///// メソッド
64
       procedure MakeArray; override;
65
     public
66
       constructor Create; overload;
67
       constructor Create( const ItemsX_,ItemsY_:Integer ); reintroduce; overload;
68
       constructor Create( const ItemsX_,ItemsY_,Margs_:Integer ); overload;
69
       constructor Create( const ItemsX_,ItemsY_,MargsX_,MargsY_:Integer ); overload; virtual;
70
       destructor Destroy; override;
71
       ///// プロパティ
72
       property ElemsY                        :Integer read GetElemsY                ;
73
       property Elems[ const X_,Y_:Integer ]  :_TItem_ read GetElems  write SetElems ;
74
       property ElemsP[ const X_,Y_:Integer ] :_PItem_ read GetElemsP                ;
75
       property ItemsY                        :Integer read GetItemsY write SetItemsY;
76
       property MargsY                        :Integer read GetMargsY write SetMargsY;
77
       property ItemsN                        :Integer read GetItemsN                ;
78
       property Items[ const X_,Y_:Integer ]  :_TItem_ read GetItems  write SetItems ; default;
79
       property ItemsP[ const X_,Y_:Integer ] :_PItem_ read GetItemsP                ;
80
       property Item0P                        :Pointer read GetItem0P                ;
81
       ///// メソッド
82
       procedure MakeEdgeLoop;
83
     end;
84

85
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TCellArray2D<_TItem_>
86

87
     ICellArray2D = interface( IArray2D )
88
     ['{F942004C-5B06-4744-9E7C-7E5FCB6258A5}']
89
       ///// アクセス
90
       function GetPoinsX :Integer;
91
       procedure SetPoinsX( const PoinX_:Integer );
92
       function GetPoinsY :Integer;
93
       procedure SetPoinsY( const PoinY_:Integer );
94
       ///// プロパティ
95
       property CellsX :Integer read GetItemsX write SetItemsX;
96
       property CellsY :Integer read GetItemsY write SetItemsY;
97
       property PoinsX :Integer read GetPoinsX write SetPoinsX;
98
       property PoinsY :Integer read GetPoinsY write SetPoinsY;
99
     end;
100

101
     //-------------------------------------------------------------------------
102

103
     TCellArray2D<_TItem_> = class( TArray2D<_TItem_>, ICellArray2D )
104
     private
105
     protected
106
       ///// アクセス
107
       function GetPoinsX :Integer;
108
       procedure SetPoinsX( const PoinsX_:Integer );
109
       function GetPoinsY :Integer;
110
       procedure SetPoinsY( const PoinsY_:Integer );
111
     public
112
       ///// プロパティ
113
       property Cells[ const X_,Y_:Integer ] :_TItem_ read GetItems  write SetItems ; default;
114
       property CellsX                       :Integer read GetItemsX write SetItemsX;
115
       property CellsY                       :Integer read GetItemsY write SetItemsY;
116
       property PoinsX                       :Integer read GetPoinsX write SetPoinsX;
117
       property PoinsY                       :Integer read GetPoinsY write SetPoinsY;
118
       ///// メソッド
119
       procedure MakeEdgePerio; override;
120
       procedure MakeEdgeMirro; override;
121
     end;
122

123
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TPoinArray2D<_TItem_>
124

125
     IPoinArray2D = interface( IArray2D )
126
     ['{7E34AB1F-480A-4CCF-9719-7938AA1015A9}']
127
       ///// アクセス
128
       function GetCellsX :Integer;
129
       procedure SetCellsX( const CellsX_:Integer );
130
       function GetCellsY :Integer;
131
       procedure SetCellsY( const CellsY_:Integer );
132
       ///// プロパティ
133
       property PoinsX :Integer read GetItemsX write SetItemsX;
134
       property PoinsY :Integer read GetItemsY write SetItemsY;
135
       property CellsX :Integer read GetCellsX write SetCellsX;
136
       property CellsY :Integer read GetCellsY write SetCellsY;
137
     end;
138

139
     //-------------------------------------------------------------------------
140

141
     TPoinArray2D<_TItem_> = class( TArray2D<_TItem_>, IPoinArray2D )
142
     private
143
     protected
144
       ///// アクセス
145
       function GetCellsX :Integer;
146
       procedure SetCellsX( const CellsX_:Integer );
147
       function GetCellsY :Integer;
148
       procedure SetCellsY( const CellsY_:Integer );
149
     public
150
       constructor Create( const CellsX_,CellsY_,MargsX_,MargsY_:Integer ); override;
151
       destructor Destroy; override;
152
       ///// プロパティ
153
       property Poins[ const X_,Y_:Integer ] :_TItem_ read GetItems  write SetItems ; default;
154
       property PoinsX                       :Integer read GetItemsX write SetItemsX;
155
       property PoinsY                       :Integer read GetItemsY write SetItemsY;
156
       property CellsX                       :Integer read GetCellsX write SetCellsX;
157
       property CellsY                       :Integer read GetCellsY write SetCellsY;
158
       ///// メソッド
159
       procedure MakeEdgePerio; override;
160
       procedure MakeEdgeMirro; override;
161
     end;
162

163
//const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
164

165
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
166

167
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
168

169
implementation //############################################################### ■
170

171
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
172

173
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
174

175
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TArray2D<_TItem_>
176

177
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
178

179
/////////////////////////////////////////////////////////////////////// メソッド
180

181
function TArray2D<_TItem_>.ElemsI( const X_,Y_:Integer ) :Integer;
182
begin
183
     Result := Y_ * _ElemsX + X_;
184
end;
185

186
function TArray2D<_TItem_>.ItemsI( const X_,Y_:Integer ) :Integer;
187
begin
188
     Result := ( _MargsY + Y_ ) * _ElemsX + ( _MargsX + X_ );
189
end;
190

191
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
192

193
/////////////////////////////////////////////////////////////////////// アクセス
194

195
function TArray2D<_TItem_>.GetElemsN :Integer;
196
begin
197
     Result := _ElemsY * _ElemsX;
198
end;
199

200
//------------------------------------------------------------------------------
201

202
function TArray2D<_TItem_>.GetElemsY :Integer;
203
begin
204
     Result := _ElemsY;
205
end;
206

207
//------------------------------------------------------------------------------
208

209
function TArray2D<_TItem_>.GetElems( const X_,Y_:Integer ) :_TItem_;
210
begin
211
     Result := _Elems[ ElemsI( X_, Y_ ) ];
212
end;
213

214
procedure TArray2D<_TItem_>.SetElems( const X_,Y_:Integer; const Elem_:_TItem_ );
215
begin
216
     _Elems[ ElemsI( X_, Y_ ) ] := Elem_;
217
end;
218

219
function TArray2D<_TItem_>.GetElemsP( const X_,Y_:Integer ) :_PItem_;
220
begin
221
     Result := @_Elems[ ElemsI( X_, Y_ ) ];
222
end;
223

224
//------------------------------------------------------------------------------
225

226
function TArray2D<_TItem_>.GetItemsY :Integer;
227
begin
228
     Result := _ItemsY;
229
end;
230

231
procedure TArray2D<_TItem_>.SetItemsY( const ItemsY_:Integer );
232
begin
233
     _ItemsY := ItemsY_;  MakeArray;
234
end;
235

236
function TArray2D<_TItem_>.GetMargsY :Integer;
237
begin
238
     Result := _MargsY;
239
end;
240

241
procedure TArray2D<_TItem_>.SetMargsY( const MargsY_:Integer );
242
begin
243
     _MargsY := MargsY_;  MakeArray;
244
end;
245

246
function TArray2D<_TItem_>.GetItemsN :Integer;
247
begin
248
     Result := _ItemsY * _ItemsX;
249
end;
250

251
//------------------------------------------------------------------------------
252

253
function TArray2D<_TItem_>.GetItems( const X_,Y_:Integer ) :_TItem_;
254
begin
255
     Result := _Elems[ ItemsI( X_, Y_ ) ];
256
end;
257

258
procedure TArray2D<_TItem_>.SetItems( const X_,Y_:Integer; const Item_:_TItem_ );
259
begin
260
     _Elems[ ItemsI( X_, Y_ ) ] := Item_;
261
end;
262

263
function TArray2D<_TItem_>.GetItemsP( const X_,Y_:Integer ) :_PItem_;
264
begin
265
     Result := @_Elems[ ItemsI( X_, Y_ ) ];
266
end;
267

268
function TArray2D<_TItem_>.GetItem0P :Pointer;
269
begin
270
     Result := GetItemsP( 0, 0 );
271
end;
272

273
/////////////////////////////////////////////////////////////////////// メソッド
274

275
procedure TArray2D<_TItem_>.MakeArray;
276
begin
277
     _ElemsY := _MargsY + _ItemsY + _MargsY;
278

279
     inherited;
280
end;
281

282
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
283

284
constructor TArray2D<_TItem_>.Create;
285
begin
286
     Create( 0, 0 );
287
end;
288

289
constructor TArray2D<_TItem_>.Create( const ItemsX_,ItemsY_:Integer );
290
begin
291
     Create( ItemsX_, ItemsY_, 0 );
292
end;
293

294
constructor TArray2D<_TItem_>.Create( const ItemsX_,ItemsY_,Margs_:Integer );
295
begin
296
     Create( ItemsX_, ItemsY_, Margs_, Margs_ );
297
end;
298

299
constructor TArray2D<_TItem_>.Create( const ItemsX_,ItemsY_,MargsX_,MargsY_:Integer );
300
begin
301
     inherited Create( ItemsX_, MargsX_ );
302

303
     _ItemsY := ItemsY_;
304
     _MargsY := MargsY_;
305
end;
306

307
destructor TArray2D<_TItem_>.Destroy;
308
begin
309

310
     inherited;
311
end;
312

313
/////////////////////////////////////////////////////////////////////// メソッド
314

315
procedure TArray2D<_TItem_>.MakeEdgeLoop;
316
var
317
   EX, EY, MX, MY :Integer;
318
begin
319
     for EY := -_MargsY to -1 do
320
     begin
321
          MY := EY + _ItemsY;
322

323
          for EX := -_MargsX to                -1 do Items[ EX, EY ] := Items[ EX + _ItemsX, MY ];
324
          for EX :=  0       to _ItemsX        -1 do Items[ EX, EY ] := Items[ EX          , MY ];
325
          for EX :=  _ItemsX to _ItemsX+_MargsX-1 do Items[ EX, EY ] := Items[ EX - _ItemsX, MY ];
326
     end;
327

328
     for EY := 0 to _ItemsY-1 do
329
     begin
330
          for EX := -_MargsX to                -1 do Items[ EX, EY ] := Items[ EX + _ItemsX, EY ];
331

332
          for EX :=  _ItemsX to _ItemsX+_MargsX-1 do Items[ EX, EY ] := Items[ EX - _ItemsX, EY ];
333
     end;
334

335
     for EY := _ItemsY to _ItemsY+_MargsY-1 do
336
     begin
337
          MY := EY - _ItemsY;
338

339
          for EX := -_MargsX to                -1 do Items[ EX, EY ] := Items[ EX + _ItemsX, MY ];
340
          for EX :=  0       to _ItemsX        -1 do Items[ EX, EY ] := Items[ EX          , MY ];
341
          for EX :=  _ItemsX to _ItemsX+_MargsX-1 do Items[ EX, EY ] := Items[ EX - _ItemsX, MY ];
342
     end;
343
end;
344

345
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TCellArray2D<_TItem_>
346

347
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
348

349
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
350

351
/////////////////////////////////////////////////////////////////////// アクセス
352

353
function TCellArray2D<_TItem_>.GetPoinsX :Integer;
354
begin
355
     Result := CellsX + 1;
356
end;
357

358
procedure TCellArray2D<_TItem_>.SetPoinsX( const PoinsX_:Integer );
359
begin
360
     CellsX := PoinsX_ - 1;
361
end;
362

363
function TCellArray2D<_TItem_>.GetPoinsY :Integer;
364
begin
365
     Result := CellsY + 1;
366
end;
367

368
procedure TCellArray2D<_TItem_>.SetPoinsY( const PoinsY_:Integer );
369
begin
370
     CellsY := PoinsY_ - 1;
371
end;
372

373
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
374

375
/////////////////////////////////////////////////////////////////////// メソッド
376

377
procedure TCellArray2D<_TItem_>.MakeEdgePerio;
378
var
379
   MX, MY, NX, NY, HX, HY, X, Y :Integer;
380
begin
381
     //                                     H   N
382
     //                                     |   |
383
     //    -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8
384
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
385
     //    +3  +4  +5  ・  ・  ・  ・  ・  ・  00  +1  +2
386

387
     MX := _MargsX;  NX := _ItemsX;  HX := _ItemsX-1;
388
     MY := _MargsY;  NY := _ItemsY;  HY := _ItemsY-1;
389

390
     for Y := 00 to HY do
391
     begin
392
          for X := 00-MX to 00-01 do Items[ X, Y ] := Items[ X + NX, Y ];
393
          for X := HX+01 to HX+MX do Items[ X, Y ] := Items[ X - NX, Y ];
394
     end;
395

396
     for X := 00-MX to HX+MX do
397
     begin
398
          for Y := 00-MY to 00-01 do Items[ X, Y ] := Items[ X, Y + NY ];
399
          for Y := HY+01 to HY+MY do Items[ X, Y ] := Items[ X, Y - NY ];
400
     end;
401
end;
402

403
procedure TCellArray2D<_TItem_>.MakeEdgeMirro;
404
var
405
   MX, MY, NX, NY, HX, HY, X, Y :Integer;
406
begin
407
     //                                     H   N
408
     //                                     |   |
409
     //    -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8
410
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
411
     //    +2  +1  00  ・  ・  ・  ・  ・  ・  +5  +4  +3   }
412

413
     MX := _MargsX;  NX := _ItemsX;  HX := _ItemsX-1;
414
     MY := _MargsY;  NY := _ItemsY;  HY := _ItemsY-1;
415

416
     for Y := 00 to HY do
417
     begin
418
          for X := 00-MX to 00-01 do Items[ X, Y ] := Items[ 00 - X - 01, Y ];
419
          for X := HX+01 to HX+MX do Items[ X, Y ] := Items[ HX - X + NX, Y ];
420
     end;
421

422
     for X := 00-MX to HX+MX do
423
     begin
424
          for Y := 00-MY to 00-01 do Items[ X, Y ] := Items[ X, 00 - Y - 01 ];
425
          for Y := HY+01 to HY+MY do Items[ X, Y ] := Items[ X, HY - Y + NY ];
426
     end;
427
end;
428

429
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TPoinArray2D<_TItem_>
430

431
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
432

433
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
434

435
/////////////////////////////////////////////////////////////////////// アクセス
436

437
function TPoinArray2D<_TItem_>.GetCellsX :Integer;
438
begin
439
     Result := _ItemsX - 1;
440
end;
441

442
procedure TPoinArray2D<_TItem_>.SetCellsX( const CellsX_:Integer );
443
begin
444
     _ItemsX := CellsX_ + 1;  MakeArray;
445
end;
446

447
function TPoinArray2D<_TItem_>.GetCellsY :Integer;
448
begin
449
     Result := _ItemsY - 1;
450
end;
451

452
procedure TPoinArray2D<_TItem_>.SetCellsY( const CellsY_:Integer );
453
begin
454
     _ItemsY := CellsY_ + 1;  MakeArray;
455
end;
456

457
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
458

459
constructor TPoinArray2D<_TItem_>.Create( const CellsX_,CellsY_,MargsX_,MargsY_:Integer );
460
begin
461
     inherited Create( CellsX_+1, CellsY_+1,
462
                       MargsX_  , MargsY_   );
463

464
end;
465

466
destructor TPoinArray2D<_TItem_>.Destroy;
467
begin
468

469
     inherited;
470
end;
471

472
/////////////////////////////////////////////////////////////////////// メソッド
473

474
procedure TPoinArray2D<_TItem_>.MakeEdgePerio;
475
var
476
   MX, MY, HX, HY, X, Y :Integer;
477
begin
478
     //                                       H
479
     //                                       |
480
     //  -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8  +9
481
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
482
     //  +3  +4  +5  ・  ・  ・  ・  ・  ・  00  +1  +2  +3
483

484
     MX := _MargsX;  HX := _ItemsX-1;
485
     MY := _MargsX;  HY := _ItemsX-1;
486

487
     for Y := 00 to HY do
488
     begin
489
          for X := 00-MX to 00-01 do Items[ X, Y ] := Items[ X + HX, Y ];
490
          for X := HX+00 to HX+MX do Items[ X, Y ] := Items[ X - HX, Y ];
491
     end;
492

493
     for X := 00-MX to HX+MX do
494
     begin
495
          for Y := 00-MY to 00-01 do Items[ X, Y ] := Items[ X, Y + HY ];
496
          for Y := HY+00 to HY+MY do Items[ X, Y ] := Items[ X, Y - HY ];
497
     end;
498
end;
499

500
procedure TPoinArray2D<_TItem_>.MakeEdgeMirro;
501
var
502
   MX, MY, HX, HY, X, Y :Integer;
503
begin
504
     //                                       H
505
     //                                       |
506
     //  -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8  +9
507
     //  ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
508
     //  +3  +2  +1  ・  ・  ・  ・  ・  ・  ・  +5  +4  +3
509

510
     MX := _MargsX;  HX := _ItemsX-1;
511
     MY := _MargsX;  HY := _ItemsX-1;
512

513
     for Y := 00 to HY do
514
     begin
515
          for X := 00-MX to 00-01 do Items[ X, Y ] := Items[ -X       , Y ];
516
          for X := HX+01 to HX+MX do Items[ X, Y ] := Items[ -X + 2*HX, Y ];
517
     end;
518

519
     for X := 00-MX to HX+MX do
520
     begin
521
          for Y := 00-MY to 00-01 do Items[ X, Y ] := Items[ X, -Y        ];
522
          for Y := HY+01 to HY+MY do Items[ X, Y ] := Items[ X, -Y + 2*HY ];
523
     end;
524
end;
525

526
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
527

528
//############################################################################## □
529

530
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
531

532
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 最終化
533

534
end. //######################################################################### ■
535