Logik Problem

[Neutral General]

Hi,

Irgendwie steh ich grad total aufm Schlauch -.-
Guckt mal:

http://img72.imageshack.us/img72/6909/kollisionks4.jpg

Meine Logik war jetzt folgende - Der Spieler (S) kollidiert mit der Wand (W) rechts (also rechte Seite von Spieler gegen Linke Seite von Wand) wenn folgendes erfüllt ist:

Delphi-Quellcode:

if (X + Width >= ASprite.X) and (Y + Height >= ASprite.Y) and (Y  <= ASprite.Y + ASprite.Height) then
//...

Irgendwie haut das aber nicht hin^^ Der Spieler kollidiert immer.. Auch wenn ich irgendwo draufstehe..

Gruß
Neutral General

[sirius]

Wer ist denn ASprite?

[Die Muhkuh]

Ich gehe davon aus, dass das bestimmt ein TImageSprite der Andorra ist.

[Neutral General]

Richtig. Das ganze is voll unlogisch... Was muss denn alles erfüllt sein damit eindeutig klar ist das das Sprite (A) von links gegen die rechte Seite eines andere Sprites (B) stößt ?

1. Der rechteste Punkt von A muss größer oder gleich dem linkesten Punkt von B sein.
(A.x + A.Width >= B.X)
2. Außerdem darf der "Boden" von A mindestens den Y Wert haben den B hat.
(A.Y + A.Height >= B.Y)
3. .. und der "Kopf" darf max. so weit oben sein wie der Y Wert des Bodens von B.
(A.Y <= B.Y + B.Height)

DAS wäre meine Logik.. Aber das geht praktisch hinten und vorne nicht. Dabei z.B hab ich auch ne Kollision wenn ich Meter weit über dem Sprite B schwebe... Alles seltsam -.-

Gruß
Neutral General

[DGL-luke]

Delphi-Quellcode:

//Pseudocode; KoSy-Nullpunkt links oben
if (Player.WasLeft(Wall)) and (Player.RightEdge >= Wall.LeftEdge) then
  CollisionHorz(Player, Wall);
//Selbes für .WasRight
if (Player.WasAbove(Wall)) and (Player.BottomEdge >= Wall.TopEdge) then
  CollisionVert(Player, Wall);
//Selbes für .WasBelow

Du musst in jedem Schritt deines Kollisionssystems dir die Koordinaten des Spielers im letzten Schritt holen. war er vorher links von der Kante eine Wand und ist jetzt rechts davon, kollidiert er(entsprechend für alle anderen richtungen).

Deinen Code-Schnipsel kann ich leider nicht interpretieren: ENotEnoughInputException:'Cannot resolve Qualified Names'

[sirius]

Und du hast es auch wirklich so umgesetzt?

IntersectRect, wäre übrigens noch die billige Alternative

[Neutral General]

Also ich will/mache es so:

Ich habe ein Set:

Delphi-Quellcode:

TCollisionKind = (ckNone, ckLeft, ckTop, ckRight, ckBottom);
TCollisionPoints = Set of TCollisionKind;

Ist z.B ckRight im Set dann kann der Spieler nicht mehr nach rechts gehen:

Delphi-Quellcode:

var FCollision: TCollisionPoints;

if (GetAsyncKeyState(VK_RIGHT) < 0) and (not (ckRight in FCollision)) then
begin
 // ...
end;

In TTestSprite (mein Spieler) DoCollision:

Delphi-Quellcode:

procedure TTestSprite.DoCollision(Sprite: TSprite; var Done: boolean);
begin
  inherited DoCollision(Sprite,Done);
  FCollision := GetCollisionPoints(Sprite);

=>

Delphi-Quellcode:

function TTestSprite.GetCollisionPoints(
  ASprite: TSprite): TCollisionPoints;
begin
  // Nix machen wenn man mit dem Hintergrund kollidiert oder mit sich selbst
  if (ASprite is TBackGroundSprite) or (ASprite is TTestSprite) then 
    exit;
    
  Result := FCollision;

if (X + Width >= ASprite.X) and (Y + Height >= ASprite.Y) and (Y <= ASprite.Y + ASprite.Height) then
  Result := Result + [ckRight]
else
  Result := Result - [ckRight];

//...

end;

Ich hoffe das sind genug Infos

Gruß
Neutral General

[DGL-luke]

Also, es ist sehr kompliziert zu überprüfen ob der Spieler sich in/an einem gegenstand befindet.

Sehr viel einfacher ist es, zu überprüfen, ob er im letzten frame links von der linken kante des gegenstands war und nun plötzlich rechts davon ist.

[sirius]

Zitat von DGL-luke:

Also, es ist sehr kompliziert zu überprüfen ob der Spieler sich in/an einem gegenstand befindet.

Sehr viel einfacher ist es, zu überprüfen, ob er im letzten frame links von der linken kante des gegenstands war und nun plötzlich rechts davon ist.

Und was ist in der Zeit dazwischen? Da ist er in der Wand.

[DGL-luke]

dazwischen? Naja, kommt drauf an auf wie viel fps du das ding kriegst. Dann wird die Toleranz sehr schnell sehr klein.

PS: Newton rules