Pac-Man Hilfe

[Mavarik]

Zitat von Bjoerk:

Falls sich jemand mal mit dem Geisterverhalten genauer beschäftigt hat und auf Deutsch hier kurz erläutern könnte, wäre seeeeeeeeeeehr nett, my english is too bad. Man findet im Internet nix in german darüber.

OK noch mal ... Schau Dir den Link an!

es gibt (2 Modi) Verfolgung und Verstreuen! (Noch einen aber den lass ich mal weg)

Verfolgung:
- Blinky (rot) nimmt als Ziel die Position von Pac-Man. Es wird immer der Punkt mit kürzesten Entfernung verwendet nicht mit dem kürzesten Weg.
- Pinky (rosa) nimt als Ziel die Position von Pac-Man + 4 Cells in Pac-Man's Laufrichtung (Außer wenn Pac man nach oben läuft, weil da ein Bug im ursprünglichen Code war) da ist es 4 cells hoch 4 cells links
- Inky (hellblau) Nimmt den Vector von Blinky auf Pac-Position (+2 in Laufrichtung und verdoppelt den Vector) als Ziel
- Clyde (orange) Läuft auf Pac-Man's Position wenn er mehr als 8 Cells entfernt ist. Sonst in Richtung "seiner" Ecke.

Verstreuen
- Geister laufen in Ihre Ecken...

Die Modi wechseln je nach Level...
Level 1: 7s/20s/7s/20s/5s/20s/5s/ ~~

Dann wechseln noch die Geschwindigkeiten je nach Level oder ob im Tunnel.

Ach ja und Pac-Man kann schneller um die Ecken laufen als die Geister...
Wenn Pac Man eine Punkt frisst, hält er kurz an für 1/60s
die Geister können an den 4 gelben Punkten nicht nach oben gehen!
usw.

Anbei die entsprechenden Grafiken...

Mavarik

PS.: Hätte man auch alles aus meinen Links fischen können... (Dafür Poste ich die)


-

[Bjoerk]

Sieht nach einer Menge Timer aus? Ich glaub das ist mir ne Spur zu aufwendig.. Trotzdem danke für deine Ausführungen. Eigentlich unfassbar, daß das im großen und ganzen nur der Autor und ein Programmierer bewerkstelligt haben und das auch noch Ende der Siebziger. Respekt!!

[Sir Rufo]

Zitat von Bjoerk:

Sieht nach einer Menge Timer aus?

Um genau zu sein, braucht man für die Bewegung einen Timer

[himitsu]

Oder zwei Timer.
* Einer für die Bewegung
* und Einer für's Umschalten der Modi

Oder alles in einen Timer, mit der kleinsten nötigen Zeiteinheit (kleinster gemeinsamer Teiler) und dann bissl Mathematik (Zähler), um die größeren Zeiteinheiten rauszubekommen.

[Sherlock]

Zitat von himitsu:

Oder zwei Timer.
* Einer für die Bewegung
* und Einer für's Umschalten der Modi

Oder alles in einen Timer, mit der kleinsten nötigen Zeiteinheit (kleinster gemeinsamer Teiler) und dann bissl Mathematik (Zähler), um die größeren Zeiteinheiten rauszubekommen.

Ich war immer der Meinung es reicht für alles genau ein Timer. Man muss halt wissen, was man wann bzw. wie oft tun möchte.

Sherlock

[DeddyH]

Aus eigener Erfahrung weiß ich, dass sich mehrere Timer gerne mal gegenseitig ins Gehege kommen. Dann lieber nur einen verwenden und ggf. ein wenig mehr rechnen.

[himitsu]

Beim Programmablauf ist es seltener ein Problem, aber beim Debuggen wird es spassig, außer man debuggt schneller, als die Timer zuschlagen.

Der Debugger müsste die Timer anhalten und um die Pausenzeiten verlängern.

[Bjoerk]

Zitat von Sir Rufo:

Zitat von Bjoerk:

Sieht nach einer Menge Timer aus?

Um genau zu sein, braucht man für die Bewegung einen Timer

Zitat von himitsu:

Oder zwei Timer.
* Einer für die Bewegung
* und Einer für's Umschalten der Modi

Oder alles in einen Timer, mit der kleinsten nötigen Zeiteinheit (kleinster gemeinsamer Teiler) und dann bissl Mathematik (Zähler), um die größeren Zeiteinheiten rauszubekommen.

Zitat von DeddyH:

Aus eigener Erfahrung weiß ich, dass sich mehrere Timer gerne mal gegenseitig ins Gehege kommen. Dann lieber nur einen verwenden und ggf. ein wenig mehr rechnen.

Ich hab jetzt sogar eine Extra Komponente dafür erstellt. Ist vom Handling her dann einfacher ins Spiel zu integrieren.

Delphi-Quellcode:

unit uTimerEx;

interface

uses
  Math, Classes, ExtCtrls;

type
  TOnTimerExTimer = procedure(Timer: integer) of object;

  TTimerEx = class
  private
    FIntervall, FEnabled, FTickCount, FTimerTickCount: TList;
    FTimer: TTimer;
    FActive, FStoreActive: boolean;
    FOnTimerExTimer: TOnTimerExTimer;
    function GetCount: integer;
    function GetEnabled(Index: integer): boolean;
    function GetIntervall(Index: integer): integer;
    procedure SetActive(const Value: boolean);
    procedure SetEnabled(Index: integer; const Value: boolean);
    procedure SetIntervall(Index: integer; const Value: integer);
    function GetTickCount(Index: integer): integer;
    function GetTimerTickCount(Index: integer): integer;
    procedure SetTickCount(Index: integer; const Value: integer);
    procedure SetTimerTickCount(Index: integer; const Value: integer);
    property TickCount[Index: integer]: integer read GetTickCount write SetTickCount;
    property TimerTickCount[Index: integer]: integer read GetTimerTickCount write SetTimerTickCount;
    function GreatestCommonDivisor(A, B: integer): integer;
    function TimerIntervall: integer;
    procedure BeginUpdate;
    procedure EndUpdate;
    procedure TimerExTimer(Sender: TObject);
  public
    procedure Add(Intervall: integer = 1000; Enabled: boolean = true);
    procedure Delete(Index: integer);
    property Intervall[Index: integer]: integer read GetIntervall write SetIntervall;
    property Enabled[Index: integer]: boolean read GetEnabled write SetEnabled;
    property Active: boolean read FActive write SetActive;
    property Count: integer read GetCount;
    property OnTimerExTimer: TOnTimerExTimer read FOnTimerExTimer write FOnTimerExTimer;
    constructor Create;
    destructor Destroy; override;
  end;

implementation

{ TTimerEx }

constructor TTimerEx.Create;
begin
  FTimer := TTimer.Create(Nil);
  FTimer.Enabled := false;
  FTimer.OnTimer := TimerExTimer;
  FIntervall := TList.Create;
  FEnabled := TList.Create;
  FTickCount := TList.Create;
  FTimerTickCount := TList.Create;
end;

destructor TTimerEx.Destroy;
begin
  FActive := false;
  FTimer.Free;
  FIntervall.Free;
  FEnabled.Free;
  FTickCount.Free;
  FTimerTickCount.Free;
  inherited;
end;

procedure TTimerEx.Add(Intervall: integer = 1000; Enabled: boolean = true);
begin
  BeginUpdate;
  FIntervall.Add(Pointer(Intervall));
  if Enabled then
    FEnabled.Add(Pointer(1))
  else
    FEnabled.Add(Pointer(0));
  FTickCount.Add(Pointer(0));
  FTimerTickCount.Add(Pointer(0));
  EndUpdate;
end;

procedure TTimerEx.Delete(Index: integer);
begin
  BeginUpdate;
  FIntervall.Delete(Index);
  FEnabled.Delete(Index);
  FTickCount.Delete(Index);
  FTimerTickCount.Delete(Index);
  EndUpdate;
end;

function TTimerEx.GetCount: integer;
begin
  Result := FIntervall.Count;
end;

function TTimerEx.GetEnabled(Index: integer): boolean;
begin
  if Integer(FEnabled[Index]) = 1 then
    Result := true
  else
    Result := false;
end;

function TTimerEx.GetIntervall(Index: integer): integer;
begin
  Result := Integer(FIntervall[Index]);
end;

function TTimerEx.GetTickCount(Index: integer): integer;
begin
  Result := Integer(FTickCount[Index]);
end;

function TTimerEx.GetTimerTickCount(Index: integer): integer;
begin
  Result := Integer(FTimerTickCount[Index]);
end;

procedure TTimerEx.SetActive(const Value: boolean);
begin
  if Value then
  begin
    BeginUpdate;
    EndUpdate;
  end;
  FActive := Value;
  FTimer.Enabled := Value;
end;

procedure TTimerEx.SetEnabled(Index: integer; const Value: boolean);
begin
  if Value then
    FEnabled[Index] := Pointer(1)
  else
    FEnabled[Index] := Pointer(0);
end;

procedure TTimerEx.SetIntervall(Index: integer; const Value: integer);
begin
  BeginUpdate;
  FIntervall[Index] := Pointer(Value);
  EndUpdate;
end;

procedure TTimerEx.SetTickCount(Index: integer; const Value: integer);
begin
  FTickCount[Index] := Pointer(Value);
end;

procedure TTimerEx.SetTimerTickCount(Index: integer; const Value: integer);
begin
  FTimerTickCount[Index] := Pointer(Value);
end;

function TTimerEx.GreatestCommonDivisor(A, B: integer): integer;
var
  C: integer;
begin
  while B <> 0 do
  begin
    C := A mod B;
    A := B;
    B := C;
  end;
  Result := A;
end;

function TTimerEx.TimerIntervall: integer;
var
  I, J: integer;
begin
  Result := 1000;
  if Count = 1 then
    Result := Intervall[0]
  else
    if Count > 1 then
    begin
      Result := MaxInt;
      for I := 0 to Count - 2 do
        for J := I + 1 to Count - 1 do
          Result := Min(Result, GreatestCommonDivisor(Intervall[I], Intervall[J]));
    end;
  for I := 0 to Count - 1 do
    TickCount[I] := Intervall[I] div Result;
end;

procedure TTimerEx.BeginUpdate;
begin
  FStoreActive := FActive;
  FActive := false;
  FTimer.Enabled := false;
end;

procedure TTimerEx.EndUpdate;
var
  I: integer;
begin
  FTimer.Interval := TimerIntervall;
  for I := 0 to Count - 1 do
    TimerTickCount[I] := 0;
  FActive := FStoreActive;
  FTimer.Enabled := FStoreActive;
end;

procedure TTimerEx.TimerExTimer(Sender: TObject);
var
  I: integer;
begin
  FTimer.Enabled := false;
  try
    I := 0;
    while FActive and (I < Count) do
    begin
      TimerTickCount[I] := TimerTickCount[I] + 1;
      if TickCount[I] = TimerTickCount[I] then
      begin
        TimerTickCount[I] := 0;
        if Enabled[I] and Assigned(FOnTimerExTimer) then
          FOnTimerExTimer(I);
      end;
      Inc(I);
    end;
  finally
    if FActive then
      FTimer.Enabled := true;
  end;
end;

end.