AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren

Pac-Man Hilfe

Ein Thema von Zwinge112 · begonnen am 10. Apr 2015 · letzter Beitrag vom 23. Apr 2015
Antwort Antwort
Seite 6 von 9   « Erste     456 78     Letzte » 
Benutzerbild von Mavarik
Mavarik

Registriert seit: 9. Feb 2006
Ort: Stolberg (Rhld)
4.123 Beiträge
 
Delphi 10.3 Rio
 
#51

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 16:31
Und was ist bei 73,4%?

Man nimmt die Zeit bis vorm letzten Zeichnen und weiß, wie weit man sich jetzt bewegen muß.
Pac-Man ist aber Pixelorientiert und nicht darauf ausgelegt Pixel zu überspringen!
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
43.017 Beiträge
 
Delphi 12 Athens
 
#52

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 16:41
Das kann man ja ändern.

* Intern mit Teilpixelrechnen
* auf ganze Pixel gerundet anzeigen
* oder intern mit ganzen Pixeln rechnen, aber über längere Zeit die Geschwindigkeit berechnen/verrechnen
* ...
* Zwischenschritte interpolieren
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Benutzerbild von Sir Rufo
Sir Rufo

Registriert seit: 5. Jan 2005
Ort: Stadthagen
9.454 Beiträge
 
Delphi 10 Seattle Enterprise
 
#53

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 17:08
Und was ist bei 73,4%?

Man nimmt die Zeit bis vorm letzten Zeichnen und weiß, wie weit man sich jetzt bewegen muß.
Pac-Man ist aber Pixelorientiert und nicht darauf ausgelegt Pixel zu überspringen!
Es gibt ein Zell-Raster und ein Schritt-Raster. Das Schritt-Raster hat zur damaligen Zeit (Auflösung) direkt auf das Pixel-Raster gepasst. Das geht heute nicht mehr, sonst braucht man eine Lupe.
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.
Das kann man auch anders unterdrücken, indem man zwar die Zeiten berücksichtigt, aber egal wie lange der Zeit zwischen den Berechnungen gedauert hat, es werden maximal nur 2 Schritte berechnet.
Kaum macht man's richtig - schon funktioniert's
Zertifikat: Sir Rufo (Fingerprint: ‎ea 0a 4c 14 0d b6 3a a4 c1 c5 b9 dc 90 9d f0 e9 de 13 da 60)

Geändert von Sir Rufo (14. Apr 2015 um 17:11 Uhr)
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
43.017 Beiträge
 
Delphi 12 Athens
 
#54

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 17:30
Diese Aussage bezog sich nur auf mehrere Timer. (noch ohne die Betrachtung einer Interpolation)

* Timer1 = 100 ms
* Timer2 = 500 ms

Timer1 müsste also 5 Mal so oft auslösen, wie Timer2,
aber wenn man jetzt mehr als 100 ms benötigt, zum Debuggen einer Methode (bis zum nächsten ProcessMessage), dann verschiebt sich das natürlich.

Oder besonders schön wird es, wenn man ProcessMessages im Code drin hat.
* Timer-Event benöigt 10 ms, das Timer-Intervall ist 100 ms
Das geht normaler Weise, wenn man jetzt debuggt und mehr als 100 ms bis zum ProcessMessages braucht, dann debuggt man sich in eine Endlosschleife, weil in dem ProcessMessages der Timer erneut ausgelöst wird, bevor das aktuelle Event fertig geworden ist.
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests

Geändert von himitsu (14. Apr 2015 um 17:34 Uhr)
  Mit Zitat antworten Zitat
mkinzler
(Moderator)

Registriert seit: 9. Dez 2005
Ort: Heilbronn
39.851 Beiträge
 
Delphi 11 Alexandria
 
#55

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 17:32
Dann wäre es aber Aktion2 nur bei jedem 5. Durchlauf des Timers auszuführen
Markus Kinzler
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
43.017 Beiträge
 
Delphi 12 Athens
 
#56

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 17:42
Siehst'e ... also ist doch ein Timer besser als zwei/mehr Timer.
Somit haben wir den Beweis dafür.
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Popov
(Gast)

n/a Beiträge
 
#57

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 22:38
Pac-Man zu programmieren ist sowas von 1980. Sparrt euch die Arbeit, denn bald kommt der Pac-Man Film.

Hier der Trailer: https://www.youtube.com/watch?v=MAT0TpYMswI
  Mit Zitat antworten Zitat
Bjoerk

Registriert seit: 28. Feb 2011
Ort: Mannheim
1.384 Beiträge
 
Delphi 10.4 Sydney
 
#58

AW: Pac-Man Hilfe

  Alt 14. Apr 2015, 22:45
Schweinerei. PacMan ist nicht böse.
  Mit Zitat antworten Zitat
Bjoerk

Registriert seit: 28. Feb 2011
Ort: Mannheim
1.384 Beiträge
 
Delphi 10.4 Sydney
 
#59

AW: Pac-Man Hilfe

  Alt 20. Apr 2015, 13:54
Sieht nach einer Menge Timer aus?
Um genau zu sein, braucht man für die Bewegung einen Timer
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.
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.
  Mit Zitat antworten Zitat
Benutzerbild von Sherlock
Sherlock

Registriert seit: 10. Jan 2006
Ort: Offenbach
3.753 Beiträge
 
Delphi 11 Alexandria
 
#60

AW: Pac-Man Hilfe

  Alt 20. Apr 2015, 16:03
Neugier: Wieso verwendest Du Pointer und nicht die Werte an sich?

Sherlock
Oliver
Geändert von Sherlock (Morgen um 16:78 Uhr) Grund: Weil ich es kann
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 12:01 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz