Java 2D-kollision, vattentätt, kameran följer karaktären

Du flyttar gubben 1 pixel upp, alla andra objekt är stilla.

Eller du flyttar alla objekt 1 pixel ner, gubben är stilla.

Resten är bara en fråga om vilken del av banan som syns.

----* (utanför skärmen, bara för att du skall se nästa frame)
skärmen slutar
*****
*****
**#**
*--**
*---*

Hade gubben (#) gått 1 pixel upp, så hade inga objekt rört på sig (- är objekt, * är gräs) utom gubben rör sig, och sedan ritar man upp de pixlarna som syns på skärmen. Då hade den sett ut såhär:

----*
*****
**#**
*****
*--**
skärmen slutar
*---* (syns inte längre).

Notera att gubben alltid är mitt i skärmen.

Vad jag förstår av din exempel är typ att du gör flyttning 2 gånger per frame/tidsenhet. Det är väl fel gjort av dig?

För att tillägga, låt oss säga att din gubbe flyttar sig 10 pixlar per sekund.

Det är hans hastighet, 10 pixlar / sekund.

Men som du gör är faktiskt att gubben rör sig 20 pixlar per sekund (såvida de andra objekt inte är andra monster som också rör sig med 10 pixlar per sekund i motsatt riktning).

Så det verkar vara fel på logiken som du har använt.

Du verkar flytta objekten neråt istället för att flytta "skärmens synfält".

Så du har en statisk karta på typ 10 x 10 pixlar, istället för ett tittfönster på 10 x 10 pixlar och en karta på låt oss säga 1000 x 1000 pixlar (dock så är typ bara 16 x 16 utritade för att du skall kunna snabbt flytta kameran).

Men din kod borde se ut typ såhär:

int charNextXleft = character.getX() + charMoveX;
int charNextXright = charNextXleft + character.getWidth();
int enemyNextXleft = enemy.getX() + enemyMoveX;
int enemyNextXright = enemyNextXleft + enemy.getWidth();
(Samma för y)
if (charNextXleft <= enemyNextXright && charNextXright >= enemyNextXleft && samma för Y)
{
// kollision
}
else if ((charNextXleft > enemyCurrentXright && enemyNextXright <= enemyCurrentXright && charCurrentXleft < enemyCurrentXright || charNextXright < enemyCurrentXleft && enemyNextXleft >= enemyCurrentXleft && charCurrentXright > enemyCurrentXleft) && (samma for Y))
{
// kollision, objekt gick om varandra
}
else
{
// ingen kollision
}

Typ så borde kollisions koden se ut. Hoppas jag fick rätt på alla left och right och > och <. Men du fattar poängen.

Observera att varje objekt, inklusive din gubbe har en riktning och en hastighet.

Dvs din gubbe går med hastighet 4 åt höger och är 3 pixlar bred.
Motståndare går åt vänster med hastighet 2 och är 2 pixlar bred.

******###**--** (# = din gubbe, - = motståndare)
Nästa frame:
*****-$##****** ($ = kollision)

Men om vi säger att motsåndaren hade hastighet 3 pixlar, då hade det sett ut såhär:
****--###******
Utan "else if" hade ditt program inte hittat kollisionen.

Men det du gör fel är att du flyttar objektet två gånger.
*--***###****** (2 pixlar på monstret + 4 i motsat gubbriktning)
eller
--****###****** (3 pixlar på monstret + 4 i motsat gubbriktning)

Du ser nu att du gör fel.

Du måste ha gubben statisk (flytta inte den alls!) när du flyttar alla objekt.
Eller så flyttar du endast gubben sedan kameran. Och alla objekt står still.

Annars får du dubbel flyttning.

Nästan precis så, fast du fick fel på steg 4 (se nedan).

Vi säger 10 pixlar upp på karaktären:

Steg 1: Flytta karaktär 10 pixlar upp.
Steg 2: Flytta alla objekt som rör sig med deras egna hastighet (utom karaktären då, eftersom du flyttade på den i steg 1, du kan såklart slå ihop steg 1 och 2 till ett steg för alla objekt inklusive karaktären).
Steg 3: Kör collision detection.
Steg 4: Flytta allt inklusive karaktären 10 pixlar ner (motsatt riktning).

Då hamnar karaktären på samma ställe som förr, dvs mitt i skärmen. Och allt annat flyter på.

Din JPanel är återspegling av fragment av hela kartan.

Vi säger detta är hela kartan där * = karta som inte syns och ¤ = återspegling av kartan på din JPanel (anta din skärm är 2x3 pixlar stor):

******
******
******
***¤¤*
***¤¤*
***¤¤*
******

När gubben går 1 pixel åt vänster, så ändras inte världen (själva kartan) utom endast det din JPanel ritar. Vet inte hur du får det till men antar att det är som en canvas som du ritar dina objekt på.
******
******
******
**¤¤**
**¤¤**
**¤¤**
******

Så tittfönstret ändrades, och du måste återspegla det i din JPanel.

Lättast är väl att:

1: Flytta gubben 1 pixel vänster.
2: Flytta alla objekt så som dem skall flytta sig.
3: Kollisions detektering.
4: Flytta hela grafiken i fönstret 1 pixel höger (gubbe fortfarande centrerad).
5: Rita 1 pixel bred grafik från kartan (det nya som nu syns). Oftast så har man ingen grafisk representation för kartan i minnet, utom endast data som säger at det finns si och sådan tile här och där. Så du får rita upp grafiken baserat på den informationen.

Oftast så är det så att din gubbe rör sig 1 tile, en tile är X * Y bred (typ 16 * 16). Så du ritar bara tilen som numera syns.

http://sv.wikipedia.org/wiki/Model-View-Controller

Rekommenderar MVC om du inte redan använder dig utav denna modellen!

Tänk på att jag är trött och det var bara ett exempel.

"else if" satsen bör ses över så du får kolla om jag tagit med alla scenario.
Jag tror inte att den kommer fungera om båda går i samma riktning, men ändå går om varandra. Men som sagt, för lite tid och för trött för att tänka nu!

Jag kan kolla lite på det imorgon efter jobb om jag har tid och är uttråkad.