1:
2:
3:
4:
5:
6:
7:
8:
9:

const abbruch:boolean = true;
//weiter unten:
if not abbruch then
    begin
       abbruch:=true;
       exit;
    end;

    abbruch:=false;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:

unit uTAmeise;

{Zur Info: 2DDDynArray steht für ein 2D Array das Doppel Dynamisch ist !
man kann es also in den negativen und in den positiven Bereich vergrößern,
diese Unit ist selbstgeschrieben, aber die Methoden sind selbsterklärend}

interface

uses Windows, uT2DDDynArray, Graphics;

Procedure FeldErstellen;
Procedure FeldFree;
Procedure FeldZeichne( var Bild: TBitmap );

type
  TAmeise = class
    private
    Schritte: Cardinal;
    //Ameise
      SAusrichtung,
      Ausrichtung: ShortInt;
      Position: TPoint;
      BG, BUG: ShortInt;
      procedure gehRechts;
      procedure gehLinks;
      procedure lauf;
    public
      property Schritt: Cardinal read Schritte;
      property StartAusrichtung: ShortInt read SAusrichtung;
      property BeiUngeraden: ShortInt read BUG;
      property BeiGeraden: ShortInt read BG;

      constructor create(Start_Ausrichtung, Bei_Ungeraden, Bei_Geraden: ShortInt);
      procedure EinWeiter;
      procedure Weiter( AnzahlSchritte: Cardinal );
      procedure GehAuf( SchrittNr: Cardinal );
      procedure setBeiUngeraden( Bei_Ungeraden: ShortInt );
      procedure setBeiGeraden( Bei_Geraden: ShortInt );
      destructor destroy; override;

      procedure Zeichne( var Bild: TBitmap; ZStartpunkt, ZPosition: Boolean );
  end;

var
  Feld: T2DArray;

const
  //weiss = false;
  //schwarz = true;
  Oben = 0;
  Rechts = 1;
  Unten = 2;
  Links = 3;

  WSize = 0; //startgröße (x: -wsize..wsize;)
  HSize = 0; //startgröße (y: -hsize..hsize;)

implementation

//Ameisen- unanhäniger Teil
Procedure FeldErstellen;
begin
//FeldFree;
Feld := T2DArray.create( -WSize, WSize, -HSize, HSize, weiss);
end;

Procedure FeldFree;
begin
Feld.Free;
end;

Procedure FeldZeichne( var Bild: TBitmap );
begin
  Feld.zeichne( Bild );
end;


//Ameisen-Teil

//private teil
procedure TAmeise.gehRechts;
begin
  case Ausrichtung of
    Oben:     Ausrichtung := Rechts;
    Rechts:   Ausrichtung := Unten;
    Unten:    Ausrichtung := Links;
    Links :   Ausrichtung := Oben;
    else
  end;
end;

procedure TAmeise.gehLinks;
begin
  case Ausrichtung of
    Oben:     Ausrichtung := Links;
    Rechts:   Ausrichtung := Oben;
    Unten:    Ausrichtung := Rechts;
    Links :   Ausrichtung := Unten;
    else
  end;
end;

procedure TAmeise.lauf;
begin
  case Ausrichtung of
    Oben:     dec(Position.Y);
    Rechts:   inc(Position.X);
    Unten:    inc(Position.Y);
    Links:    dec(Position.X);
    else
  end;
end;



//--------------------------------public- Teil---------------------------

constructor TAmeise.create(Start_Ausrichtung, Bei_Ungeraden, Bei_Geraden: ShortInt);
begin
Schritte := 0;
Ausrichtung := Start_Ausrichtung;
SAusrichtung := Start_Ausrichtung;
BG := Bei_Geraden;
BUG := Bei_Ungeraden;
Position.X := 0;
Position.Y := 0;
end;

procedure TAmeise.EinWeiter;
  procedure Dreh(Richtung: ShortInt);
    begin
      case Richtung of
        Oben:   begin end;
        Rechts: gehRechts;
        Unten:  begin gehRechts; gehRechts; end; //gehLinks; gehLinks;
        Links: gehLinks;
        else
      end;
    end;
begin
if Feld.read( Position.X, Position.Y) then //=schwarz    (BG)
  begin
  Feld.write( Position.X, Position.Y, weiss);
  //gehLinks;
  Dreh( BG );
  end
else //if not Feld.read( Position.X, Position.Y) then //=weiss  (BUG)
  begin
  Feld.write( Position.X, Position.Y, schwarz);
  //gehRechts;
  Dreh( BUG );
  end;
lauf;
Feld.sfnE( Position.X, Position.Y ); { Erzeuge Feld falls nicht existiert}
inc(Schritte);
end;

procedure TAmeise.Weiter( AnzahlSchritte: Cardinal );
var C: Cardinal;
begin
For C := 1 to AnzahlSchritte do
  EinWeiter;
end;

procedure TAmeise.GehAuf( SchrittNr: Cardinal );
begin
if SchrittNr >= Schritt then
  Weiter( SchrittNr - Schritt )
else
  begin
  free;
  create( SAusrichtung, BUG, BG );
  Weiter( SchrittNr );
  end;
end;

procedure TAmeise.setBeiUngeraden( Bei_Ungeraden: ShortInt );
begin
BUG := Bei_Ungeraden;
end;

procedure TAmeise.setBeiGeraden( Bei_Geraden: ShortInt );
begin
BG := Bei_Geraden;
end;


//für User
procedure TAmeise.Zeichne( var Bild: TBitmap; ZStartpunkt, ZPosition: Boolean );
begin
//Startpunkt lime kreuzen
if ZStartpunkt then
  Feld.UmrandePixel( Bild, 0, 0, cllime, bsBDiagonal);
//aktuelle Position rot umranden
if ZPosition then
  Feld.UmrandePixel( Bild, Position.X, Position.Y , clred, bsClear);
end;

initialization
  FeldErstellen;

finalization
  FeldFree;
end.                    

1:
2:
3:
4:
5:

      case Regelstring[6 * i + 3 * j + 1] of
        '1': Regel[i, j, 0] := 1; // weiß
        else
          Regel[i, j, 0] := 0;//schwarz
      end;                    

1:
2:
3:
4:
5:
6:

        //Farbe nach Zustand setzen
         s := Speicher[y,x];
//         pPixel := pScanLines[y];inc(pPixel,x); pPixel^ := Farben[Regel[Zustand,s,0]];
         TempBitmap.canvas.Pixels[x,y]:= Farben[Regel[Zustand,s,0]];

         Speicher[y,x] := Regel[Zustand,s,0];                    

1:

(StringSplit["LRRLLLRR", ""] /. {"R" -> 1, "L" -> 0})~FromDigits~2