[Java] keylistener voor zelda-spel

[Anoniem: 36591]

Ik ben bezig een zelda 1 achtig spel te maken (voor de nes, is werkstuk informatica) en naast dat ik algemene tips erg zou waarderen over collision en animatie (algemene problemen waar ik volgens kenners nog tegen aan zal stuiten) heb ik ook een specifieke vraag. De hoofdklasse is degene die 'luistert' naar de toetsen en die zorgt er dan voor dat er een waarde verandert, afhankelijk van de toets. Hier is dat de startplaats van een bal (wordt later een pijl of poppetje of iets dergelijks) en de bal is ook een aparte klasse. Nu moet ik ervoor zorgen dat de klassebal de informatie van die is veranderd door het indrukken van de toetsen, de nieuwe waardes dus, verkrijgt. Hoe doe ik dat; een methode maken in de hoofdklasse die die info geeft gaat niet, want die methode aanroepen in de klasse bal op het 'object' hoofdklasse (wat dus geen object is, want ik definieer en declareer het nergens) geeft een foutmelding (wat ik al verwachte, maar kon niks beters verzinnen. Hij zegt dan iets over statisch ofzo). Iemand een suggestie?

Dan heb ik nog een vraag; ik wil dat er naar de toetsen geluisterd wordt, zonder dat ik eerst een textfield moet maken en daarop moet klikken voordat de toetsactie verwerkt kunnen worden, maar een keyListener adden aan bijvoorbeeld de gehele dimensie gaat niet, het moet telkens aan een textdingetje, wat ik erg storend vind, want dan zie je in het spel bovenaan zon tekstbalkje staan.

Help me plz, de leraar begrijpt er zelf geen hout van (en dat heeft gestudeerd....)

[ACM]

Ik heb je topictitel maar even bijgewerkt.

Als je nou die hoofdklasse van je een object van de klasse bal geeft, kan je bij elke key-press toch de boel invoeren in de bal?

En daarnaast, een keylistener moet je ook aan een Panel (etc) kunnen koppelen.

[roelio]

Het probleem met de toetsen moet inderdaad beter opgelost kunnen worden maar ik heb geen oplossing voor je, ik hou me niet zo bezig met de grafische kant van Java maar meer met objecten en algoritmes... kun je niet als noodgeval de "visible" van die textbox op "false" zetten?

Over de toegang tot objecten:
Als de klasse Bal informatie moet krijgen vanuit je hoofdklasse dan kun je dat toch gewoon zo oplossen (ff als voorbeeld, niet precies jouw situatie denk ik):

code:

public class MainClass
{
  MainClass()
  {
    Bal b = new Bal();
    ...
    // nieuwe waarden of instellingen worden gelezen
    ...
    b.changeValues(waarde);
  }
}

class Bal
{
  int instelling = 1; // voorbeeld

  Bal()
  {
    ...
  }

  changeValues(int nieuweWaarde);
  {
    instelling = nieuweWaarde;
  }
}

Waarbij je methode changeValues() in klasse Bal natuurlijk zo bouwt dat de instellingen die je meegeeft (values) verwerkt worden in klasse Bal...

Wat bedoel je btw met collision in het begin van je post?

[Anoniem: 36591]

(sorry, was titel ff vergeten idd)

Als ik een listener plaats op de bal, dan luistert hij toch niet overal naar de toetsinvoer, maar alleen op de plek van de bal, toch?

Een panel gaat erg lastig (althans, toen ik dit idee idd uitwerkte een paar weken geleden), want je definieert een panel eenmalig en daarna kan je er niks meer aan veranderen (maar dat was een tijd geleden en wist ik niks van zelf methodes maken, denk nu dus eigenlijk wel).

Ja, dat met die changevalues ziet er goed uit (maar omdat het me een tijdje kost om me weer te verdiepen in me eigen programma, slechte structuur, is dat lastig zo ff uit te testen).

Met collision bedoelde ik wanneer de bal een vierkant raakt; dat vind ik erg lastig, er zijn immers heel veel combinaties mogelijk van coordinaten die kunnen samenvallen, en om dat georganiseerd te doen lijkt het me sowieso al een hele opgave...

[wasigh]

Op vrijdag 30 november 2001 19:12 schreef Exulter het volgende:
(sorry, was titel ff vergeten idd)

Als ik een listener plaats op de bal, dan luistert hij toch niet overal naar de toetsinvoer, maar alleen op de plek van de bal, toch?

Nee is niet waar, hij luisterd gewoon overal als de bal maar de focus heeft. Beter is idd om de keylistener op het (J)Panel te zetten of op het (J)Frame (oid)

Een panel gaat erg lastig (althans, toen ik dit idee idd uitwerkte een paar weken geleden), want je definieert een panel eenmalig en daarna kan je er niks meer aan veranderen (maar dat was een tijd geleden en wist ik niks van zelf methodes maken, denk nu dus eigenlijk wel).

Je kunt op een panel tekenen door middel van een Graphics object. met de methode getGraphics() kun je dat opbject opvragen. Voor wat je met het Graphics object kunt verwijs ik je naar de api-documentatie.

Ja, dat met die changevalues ziet er goed uit (maar omdat het me een tijdje kost om me weer te verdiepen in me eigen programma, slechte structuur, is dat lastig zo ff uit te testen).

Gewoon opnieuw beginnen

Met collision bedoelde ik wanneer de bal een vierkant raakt; dat vind ik erg lastig, er zijn immers heel veel combinaties mogelijk van coordinaten die kunnen samenvallen, en om dat georganiseerd te doen lijkt het me sowieso al een hele opgave...

Daarom werk ik vaak met een grid dan is dat redelijk makkelijk te doen zeker in combinatie met een 2-dimensionale array. Een dergelijk tile based oplossing is makkelijk maar geeft niet erg veel vrijheid... Voor het weergeven van de tiles kun je dan altijd een 2-dimensionale array van JButton's gebruiken deze zijn bij zichzelf dubbel buffered en kunnen erg makkelijk met images omgaan

[Anoniem: 36591]

Een grid lijkt me zelf idd wel de beste oplossing (ik ben nog maar een newbie), maar wat Jbuttons zijn en dubbelbuffered is weet ik niet, maar stel dat ik een grid heb van 30 bij 30 tiles, is het dan nog steeds niet een heksenkarwei om uit te zoeken welke tile van het balletje bijvoorbeeld een vierkant raakt?

Dat getGraphics() zag ik ook al staan in mijn boek Java stap voor stap en in de code om een balletje over het scherm te bewegen was die ook nodig, maar er staat nergens wat de methode doet. Haalt het de huidig getekende lijntjes, vierkantjes, etc op? (gekeken in api-reference, daar stond het niet errug duidelijk)

EDIT:
Kan iemand eigenlijk zeggen hoe ze vijanden verslaan regelen in professionele spellen als B&W, hoe weten ze daar bijvoorbeeld dat de vuist van de leeuw de aap raakt?

[Janoz]

Op vrijdag 30 november 2001 20:13 schreef Exulter het volgende:
Kan iemand eigenlijk zeggen hoe ze vijanden verslaan regelen in professionele spellen als B&W, hoe weten ze daar bijvoorbeeld dat de vuist van de leeuw de aap raakt?

Dat gaat nou met die collision waar je het in je eerste reactie over had .. Maar daar zou ik me op dit moment niet al te druk over gaan maken..

[Anoniem: 36591]

Met een grid doe je toch eigenlijk hetzelfde, alleen dan met aanzienlijk minder mogelijkheden (bij coordinaten dacht ik aan de pixels dus). Een grid is toch eigenlijk weinig meer dan de pixels naar grotere blokken zetten?

[Janoz]

Lijntjes en vierkantjes haal je niet op van een canvas. Wat meestal gebeurt is gewoon kijken of iets gekleurd is. Wat je mischien wel kunt doen is
1 Level mooi tekenen op je canvas
2 intern een 2 dimensionale array bijhouden van je level en van je bal. in die arrays zet je dan een doorzichtig pixel op nul en een niet doorzichtig pixel op 1. Om te kijken of er iets gebotst is kun je dan het bal-arraytje 'over' het level array leggen en vervolgens kijken of bij beide arrays op dezelfde plek een 1 staat.

[wasigh]

Op vrijdag 30 november 2001 20:33 schreef Janoz het volgende:
Lijntjes en vierkantjes haal je niet op van een canvas. Wat meestal gebeurt is gewoon kijken of iets gekleurd is. Wat je mischien wel kunt doen is
1 Level mooi tekenen op je canvas
2 intern een 2 dimensionale array bijhouden van je level en van je bal. in die arrays zet je dan een doorzichtig pixel op nul en een niet doorzichtig pixel op 1. Om te kijken of er iets gebotst is kun je dan het bal-arraytje 'over' het level array leggen en vervolgens kijken of bij beide arrays op dezelfde plek een 1 staat.

Dat is niet echt echt model-view-controller

[Clay]

Ik zou simpel beginnen niet meteen aan b&w denken.

echt proggen doen ik niet, maar ik maak wel games in dhtml. collision is iets wat ik tot nu toe bijna elke keer tegen ben gekomen. En ik heb dat ook elke keer anders opgelost, omdat de situatie gewoon verschilde. Deels komt dat natuurlijk omdat je met js extreem aan de performance moet denken.

pacman was simpel. Het spel bestond uit louter vierkanten, dus werkte ik met een grid. pacman maakten vaste stappen van een paar pixels, en 5 stappen was precies 1 gridvlak verder, dus om de 5 stappen zat een player precies midden in een veld. Dat veld had gewoon 4 booleans, en wel of je daarvandaan naar links, boven, rechts of onder kon. Collision was dus vak-specifiek, en niet gerelateerd aan de grootte van het totale speelveld, dus 1000*1000 vakken of 15 * 15 had voor de collision niet uitgemaakt.

scorched earth was ook makkelijk. (2 tankjes aan weerszijden van een heuvel landschap, zijaanzicht). Hier gebruikte ik een ander grid, van vertikale strooken van 10 pixels. De kogel wist gewoon in welke strook die zat mbv zijn x coordinaat, en elke strook had een inslag hoogte.

Nu ben ik bezig met een platform spel ala supermario dat was een beste uitdaging in javascript, maar het is gelukt het spel bestaat indirect weer uit een grid, maar dan anders. de basis van alle graphics is een 20 bij 20 vakje, en de collision bestaat uit vertikale stroken van 20 pixels breed, die een array bevatten met alle y waardes waarmee de player in botsing kan komen.
Bewegende vloeren en liften waren vrij makkelijk te integreren, die moeten per interval gewoon de y waardes in hun strook updaten.

Naja, zo denk ik dat iets als zelda ook zijn eigen aanpak behoeft wat betreft collision. En niet alleen player-world collision, maar ook wapens ed.

[Anoniem: 36591]

EDIT Aan janoz:

Dat laatste klinkt heel aardig, maar waar begin je daar mee, ik weet niet eens hoe ik kijk of een pixel gekleurd is. Denk als ik dat weet dat ik dan wel wat verder ben, met een while opdracht kan je dan alle pixels van het vierkantje afgaan om te kijken of die nog steeds de kleur van het vierkantje zelf heeft of de kleur van de bal. Klopt dat?

[Janoz]

Op vrijdag 30 november 2001 20:40 schreef Exulter het volgende:
EDIT Aan janoz:

Dat laatste klinkt heel aardig, maar waar begin je daar mee, ik weet niet eens hoe ik kijk of een pixel gekleurd is. Denk als ik dat weet dat ik dan wel wat verder ben, met een while opdracht kan je dan alle pixels van het vierkantje afgaan om te kijken of die nog steeds de kleur van het vierkantje zelf heeft of de kleur van de bal. Klopt dat?

Daarom heb ik het ook over gewone arrays. Die zijn veel makkelijker te benaderen. Je weet hoe je bal eruit ziet, en je weet hoe je level eruit ziet. Je tekend dit gewoon OOK in je arrays. Desnoods codeer je dat in eerste instantie hard in je source.


ff paar stukjes source om je op weg te helpen:

code:

int[][] veld = new int[hoogte][breedte];
int[][] bal  = new int[hbal][bbal];

boolean hit=false;
for (int y=0;y<hbal;y++) {
  for (int x=0;x<bbal;x++) {
    if (veld[xposbal+x][yposbal+y]==1) and (bal[x][y]==1) {
    hit=true;
    }
  }
}

Dit is absoluut niet de meest snelle en netste oplossing. Dan zou je eerder met Xor's een booleans moeten werken en een iets greedy-er algoritme gebruiken. Daarnaast kun je ook niet zien op welke plek de colision optreed, maar dit werkt goed om te controleren of een move 'legaal' is. Dus eerst kijken of de bal er heen mag, als dat mag, dan ook werkelijk verplaatsen.

[Anoniem: 36591]

(Voelt zich nu geheel verlicht)
Zo wordt een hoop duidelijk, maar als klein dingetje(s);
- wat doet die 1 daar in die if-voorwaarde, moet je niet de coordinaten van de bal en veld aan elkaar gelijk stellen en kijken of die hetzelfde is?
- Wat is een xor?

EDIT:
Ik weet dat Xor een operator is als OR en AND, maar niet wat hij precies doet (dat is het toch )

[wasigh]

Xor is een eXclusive Or, dat wil zeggen de uitkomst is 1 als een van beide 1 is. Als ze beide 1 zijn of beide 0 is de uitkomst 0.

de AND

code:

11010110
10110101
--------
10010100

de OR

code:

11010110
10110101
--------
11110111

de XOR

code:

11010110
10110101
--------
01100011

[Janoz]

Op vrijdag 30 november 2001 21:10 schreef Exulter het volgende:
(Voelt zich nu geheel verlicht)
Zo wordt een hoop duidelijk, maar als klein dingetje(s);
- wat doet die 1 daar in die if-voorwaarde, moet je niet de coordinaten van de bal en veld aan elkaar gelijk stellen en kijken of die hetzelfde is?

Die arrays zijn een soort maskers van je objecten. Waar ze nul zijn staat niks, waar ze 1 zijn is een stukje van je object.

Om nu te kijken of de bal iets in de level raakt moet op een bepaalde positie alebij 1 zijn.

De coordinaten worden gebruikt bij de posities in de array om op te halen of daar een 0 of een 1 staat.

- Wat is xor?

Had je zelf al gezegd

[Anoniem: 36591]

Je stelt dus bijvoorbeeld

veld[25][25] (Coordinaten zijn dus x = 25 en y=25) en AUTOMATISCH (met nadruk, omdat dat hetgene is wat ik niet vat) is veld[25][25]==1 als daar een stukje van mijn rots getekend zou staan, of moet daar nog een heel stuk aan vooraf?

EDIT
[ Niet nagedacht, zie hem nu, moet dus bij alles wat getekend worden de waarde 1 toekennen aan een array van coordinaten, is lastig voor een beginner, maar moet wat met mijn SLU (StudieLastUur, tijd die we moeten besteden aan werk)
]

[Anoniem: 36591]

Dat grid is nu gelukt (althans, in een programma dat alleen dat grid test, dus nog niet in het gehele programma, maar dat moet lukken)

Ik heb nu echt het probleem wat ik al eerder zei: Het lukt me niet om verandering door te laten werken in de startpositie van de bal. Ik kan een methode maken om de startpositie te laten veranderen, maar de methode die de bal tekent maakt geen gebruik van die nieuwe posities. Waarom weet ik absoluut niet. Ik heb de code bijgevoegd (sorry dat het zo'n lap is, maar neem plz de moeite)

code:

public class Ken4ny1 extends Applet implements ActionListener, KeyListener{
    Dimension myDimension = new Dimension(200,200);
    Button start = new Button("start");
    TextField Beweging = new TextField(10);
    Ball4 ball = new Ball4();
    public void init(){
      start.addActionListener(this);
      add(start);
      Beweging.addKeyListener(this);
      add(Beweging);    
    }
    public void actionPerformed(ActionEvent e){
      Graphics g = getGraphics();
      ball.display(g);
    }
    public void keyPressed(KeyEvent e){
      {
        if(e.getKeyChar()=='w');
        {
            ball.changey(-20);
        }
        if(e.getKeyChar()=='s');
        {
            ball.changey(20);
        }
      }
    }
    public void keyReleased(KeyEvent e)
    {
    }
    public void keyTyped(KeyEvent e)
    {
    }
}
public class Ball4 extends Applet{
    public int bxstart, bystart, xchange, ychange;
    public void init(){ 
    }
    public Ball4(){
      bxstart = 25;
      bystart = 25;
      xchange = 2;
      ychange = 2;
    }
    public void display(Graphics g)
    {
      for(int i=0; i<100; i++){
        g.setColor(Color.red);
        g.fillRect(bxstart,bystart,25,25);
        bxstart = bxstart + xchange;
        bystart = bystart + ychange;
        try{
            Thread.sleep(5);
        }
        catch(InterruptedException e){
            System.out.println("sleepexception");
        }
        g.setColor(Color.white);
        g.fillRect(bxstart-xchange, bystart-ychange,25,25);
      }
    }
    public void changex(int x){
      bxstart = bxstart + x;
    }
    public void changey(int y){
      bystart = bystart + y;
    }
}

Het zit hem dus in dat codestukje hierboven, in de classe die de bal tekent.

[Anoniem: 36591]

Iemand plz een idee

*bump*