[JAVA] Spelbord ontwikkelen dmv HEXEN????

[GAEvakYD]

Hey mensen,

Ik zit met een probleem, ik moet voor school een groot porject maken in Java. Het is de bedoeling om een soort risk te bouwen. Het speelbord moet opgebouwd zijn uit hexen(zeskanten). Ik heb alleen gbeen flauwidee hoe ik die op moet zetten.

Ik het nu zo geprobeerd, een klasse Hex daarin teken ik elke keer een hex dmv drawline als ik die aanroep. en een hoofdframe waar ik een array maak van panels met zo'n nieuwe hex erop. ik krijg nu alleen de hexen niet tegen elkaar aan. Ik heb al zitten kutten met die layout managers enzo.

code:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


public class Spelbord extends JFrame{

  private String sSenario;
  private JPanel panel[] = new DaHex[100];

  /**
   *  Default Constructor
   */
  public Spelbord() {
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });

  Container container = getContentPane();
  GridLayout gridbag = new GridLayout(5,5);
  container.setLayout(gridbag);

  for (int iTeller=0; iTeller<30; iTeller++)
  {
  panel[iTeller] = new DaHex(50);

  panel[0].setBackground(Color.black);
  container.add(panel[iTeller]);
  }

  setSize(1150,832);
  container.setVisible(true);
  }

  public Spelbord(String Senario) {
    sSenario = Senario;

    if (sSenario.equals("QuatreBras")) {
    //laad quatre bras
    }
  }

  public static void main (String[] args){
    Spelbord bord = new Spelbord();
    bord.setTitle("Quatre Bras");
    bord.setVisible(true);
  }

}

Hier is de classe DaHex

code:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


  public class DaHex extends JPanel implements ActionListener {

  private int ixA;

  public DaHex() {
  }

  public DaHex(int i) {
    ixA = i;
  }


  public void paintComponent(Graphics g){
    super.paintComponents(g);
    g.setColor(Color.black);
    g.drawLine(ixA,ixA,ixA + 60,ixA); // A-B
    g.drawLine(ixA + 60,ixA,ixA + 86,ixA + 52);  // B-C
    g.drawLine(ixA + 86,ixA + 52,ixA+60,ixA + 104); // C-D
    g.drawLine(ixA + 60,ixA + 104 ,ixA,ixA + 104); // D-E
    g.drawLine(ixA,ixA + 104,ixA - 26,ixA + 52); // E-F
    g.drawLine(ixA - 26,ixA + 52,ixA,ixA); // F-A

    }

  public void actionPerformed(ActionEvent event){
    repaint();
  }

  public void setixA(int x) {
    ixA = x;
  }


}

Please help me

[Janoz]

Waarschijnlijk kun je beter op de graphics tekenen. De meeste layout managers proberen de componenten zo dicht mogelijk aan elkaar te zetten, maar maken dan wel gebruik van een omsluitende box. Aangezien de hexen enige overlap hebben kun je waarschijnlijk niet goed met layoutmanagers werken.

[GAEvakYD]

hmmm, van graphics heb ik helemaal geen verstand.

Er moet wel achter hexje een actionlisener ,is dat ook te realiseren dan?

[Alarmnummer]

Kan je er niet een hele lading buttons ofzo van maken? En dan gewoon een gridbag layout of een table layout gebruiken.

[GAEvakYD]

Kan je een button ook andere vormen geven dan?

[Alarmnummer]

moet die button een 6 hoek worden, of moet er een 6 hoek op getekend worden? (Ik vermoed het 1e). Hmmm... volgens mij gaat het 1e wel wat lastiger worden. Maar je zou misschien ook kunnen worden met opaque kunnen werken? (Ik ben hier eerlijk gezegd niet in thuis).

[GAEvakYD]

het moeten allemaal 6 hoeken wezen, die moeten allemaal aan elkaar gerijgd worden tot 1 honingraad zeg maar

[Alarmnummer]

hmmmmm... dat word lastig Ik kan je hier helaas niet verder mee helpen..

[MisterData]

Ik ben bezig met een spelbord met vierkantjes en ik vind het al verrekte moeilijk, laat staan zeshoeken

[Alarmnummer]

Met 4kantjes is echt een eitje (heeft ooit eens 3 tier applicatie moeten maken voor n op een rij) *opdracht school* Een hele lading JButtons (met icoontjes) in een table layout

[GAEvakYD]

Klopt, vierkantjes valt wel mee. Heb hier een heel spel TicTacToo, Client Server dmv RMI. Das ook een spelbord van 9 vierkantjes.

Ik weet dus wel hoe ik de rest moet maken , maar dan moet ik wel eerst dat stomme spelbord hebben

[Verwijderd]

Ik zou het tekenen van het bord, de afhandeling van mousevents (ik neem aan dat zetten plaatsvinden door klikken op hexen), en de processing van zetten scheiden.

Na een zet eerst analyseren wat de nieuwe situatie op het bord wordt en daarna pas de graphics opnieuw tekenen.

Zo kun je ook mooi een taakverdeling maken: eerst interfaces maken voor de verschillende onderdelen, daarna kan ieder mooi z'n implementing klasse uitprogrammeren.

Aan het eind de boel samenvoegen en klaaaar

[Soultaker]

Als het alleen om het weergeven gaat, kun je het beste een LayoutManager maken die hexagonale componenten kan lay-outen. Het bepalen van de positie (linkerbovenhoek o.i.d.) van elke hexagoon is niet zo ingewikkeld als het lijkt, maar de daadwerkelijke forumele hangt af van de vorm van je speelveld en de volgorde waarin je de hexagonale vakjes aanbied aan je LayoutManager.

De op deze manier gemaakt componenten zijn niet goed klikbaar, aangezien ze gedeeltelijk overlappen. Als dat een probleem is, of je geen aparte LayoutManager wil maken, kun je natuurlijk direct je veld op een Component tekenen. De formule om dan bij een gegeven locatie het juiste veld te vinden is wat ingewikkelder en ook afhankelijk van de vorm van het speelveld.

[Verwijderd]

Ik weet niet of je er iets mee bent, maar wij hebben nooit voor school zeeslag moeten maken in java (was wel een cursus imperatief programmeren..), misschien kan je er wat ideetjes uithalen.

http://alpha.luc.ac.be/Didactiek/WNI/IK1/Java/Schip.java
http://alpha.luc.ac.be/Didactiek/WNI/IK1/Java/ZeeslagADT.java
http://alpha.luc.ac.be/Didactiek/WNI/IK1/Java/Zeeslag.java

[GAEvakYD]

ow kicke, zal een kijken of ik er iets aan heb.

Thanks man

[The Dutchman]

w00000t

deze shit gaat boven mijn petje

[GAEvakYD]

ik mis alleen de libarie import tio.* classe Zeeslag.java .

Tevens is het een console app, en ik moet juist een grapics app hebben.

Maar toch hartelijk bedankt mate

[Verwijderd]

Op vrijdag 22 maart 2002 21:43 schreef GAEvakYD het volgende:
ik mis alleen de libarie import tio.* classe Zeeslag.java .

even geupload voor je, veel plezier ermee

http://www.clueless.be/GOT/

[GAEvakYD]

Werkt wel kicke die zeeslag, zonde dat je hem console moest maken man

[Verwijderd]

Op vrijdag 22 maart 2002 21:53 schreef GAEvakYD het volgende:
Werkt wel kicke die zeeslag, zonde dat je hem console moest maken man

Zoals ik hierboven al zei: het was een cursus inleiding programmeren/imperatief programmeren... dan leer je zo'n dingen dus nog niet

[Alarmnummer]

Zorg dat je je applicatie via MVC design pattern opzet. Anders kom je wanhopig in de knoop te zitten in de (onnodige) complexiteit van je objecten. (Ik weet niet hoeveel kennis je machtig bent.. dus misschien dat ik iets heel triviaals loop te roepen)

[GAEvakYD]

Van Java heb ik niet zo gek veel kennis (Redelijk)van programmeren al wel jaren (met name c _ c++)

Maar MVC ken ik niet

[Alarmnummer]

Model View Controller is een design pattern waardoor je veel eenvoudiger gui applicaties kan schrijven. Het voordeel aan MVC is dat je je data en logica gescheiden houden van de visualisatie. Als je iets complexers wilt maken (met een gui) dan kan je eigelijk niet onder MVC uit (tenzij je ander design pattern gebruikt of ongelovelijk veel gedult hebt). Er staan op java.sun.com wel een aantal tutorials. Maar het is eigelijk een taal onafhankelijke design pattern dus er zijn ook nog genoeg andere tutorials.

MVC ruleerd

[MisterData]

Op vrijdag 22 maart 2002 20:59 schreef MisterData het volgende:
Ik ben bezig met een spelbord met vierkantjes en ik vind het al verrekte moeilijk, laat staan zeshoeken

Bij mij is het probleem niet het maken van die vierkantjes, maar het zorgen voor de borders. In het spelletje dat ik aan het maken ben gaat het om het aanstrepen van borders van die vierkantjes. En aangezien de linker-border van vierkantje 2 de rechterborder is van vierkantje 1, moet ik met allerlei constructies gaan werken om het werkend te krijgen

[GAEvakYD]

Deze jongen gaat dan effe naar de site van Sun

[GAEvakYD]

Dammit kom er niet uit. Is het misschien makkelijker om gewoon een plaatje te maken van het spelbord in Pain bijv en die op te delen in x-y coordinaten?

[eborn]

Als je nou eens een Component van zo'n vierkantje maakt met een Paint functie die voor jouw een zeshoek tekent. En dan kun je vervolgens vast wel met MouseEvents zorgen dat er iets gebeurd als je een vakje 'selecteerd'.

[Soultaker]

Dat was niet zo eenvoudig, aangezien je vierkante vakjes moet laten overlappen om aansluitende hexagonale vakjes te krijgen. Daardoor werkt het afhandelen van mouse events ook niet meer aangezien op een enkel punt meerdere vakjes over elkaar heen liggen. Het is waarschijnlijk dus makkelijker om zelf een nieuw Component te maken dat hexagonale vakjes tekenen en de mouseclicks daarop kan berekenen.

Waar gaat het nu op mis? Of ben je er helemaal niet mee begonnen? Hiervoor geldt overigens ook weer dat als je geen idee hebt waar je moet beginnen, je het hele idee misschien beter kunt laten varen, want dan ga je 't toch niet werkend krijgen. Niet lullig bedoelt verder

[GAEvakYD]

Nou het porbleem is dat ik wel die zes kantjes kan tekenen maar dat ik ze niet op elkaar aangesloten krijg tot een gesloten geheel. Heb alle Layout managers al geprobeerd

[GAEvakYD]

Nou het moet draaien want anders haal ik een half jaar van mijn school niet, dat zou mooi kut wezen omdat een grafische weergave niet lukt.

Ik ben er zeker wel mee beizg geweest zo als je kan zien op de eerste pagina(staat de code)

[djexplo]

Je kan toch gewoon 1 panel maken met daarin alle zeskantjes getekend(dus geen buttons), en dan de muis positie elke keer uitlezen als er wordt geklikt, en dan aan de hand daarvan via een formule bepalen welk zeskantje is aan geklikt, zo heb ik zelf weleens meer gekvormige buttons gemaakt

[Soultaker]

Even in de uitkauwmodus dan maar, omdat je zo wanhopig overkomt.

Ten eerste moet je de vorm van je hexagonen bepalen. In principe mogen ze elke vorm hebben, als ze maar in elkaar passen. Ik heb er bijvoorbeeld voor gekozen om alle zijden 20 pixels lang te maken en de hexagonen zelf 40 pixels breed en 48 pixels hoog. Gewoon omdat ik dat toevallig leuk vond, maar ik kan me voorstellen dat je ook op zoek zou kunnen gaan naar een een variant waarbij alle hoeken even groot zijn (en je hexagonen ook puntsymetrisch zijn). Dat is een kwestie van even uitrekenen op een kladblaadje (zoals eigenlijk alles) dus ik neem aan dat dat verder niet van belang is.

Ik gebruik voor mijn voorbeeld de volgende tekening:

Het kan handig zijn om 'm ook in een tekenprogramma te openen zodat je ook de pixelcoordinaten kan bekijken.

In de hexagonen heb ik de coordinaten gezet. Je ziet dat er eigenlijk twee soorten hexagonen zijn; die op de even rijen (die helemaal links beginnen) en die op de oneven rijen (die dus een halve hexagon naar rechts verschoven liggen).

Voor de feitelijke berekening wil ik een aantal termen invoeren. b is de breedte van een hexagon; in mijn voorbeeld 40. h is de totale hoogte van een hexagon, in mijn voorbeeld 48. t is de hoogte van de driehoekjes, als je de hexagonen opdeelt in een vierkantje met aan weerszijden een driehoekje, in mijn voorbeeld dus 14. d is de verticale verschuiving per hexagon, wat neerkomt op h-t=48-14=34 in mijn voorbeeld. Gewoon wat definitief om mee te kunnen rekenen. Deze waarden staan van te voren vast, als je de vorm van je hexagonen gekozen hebt. Tot zover niets ingewikkelds lijkt me.

Om een hexagon te tekenen heb je de zes punten ervan nodig. Ik geef deze punten beginnend bij de top en dan met de klok mee. Je kunt zelf wel die punten opsplitsen in een vierkantje en twee driehoekjes, als dat makkelijker tekenen is. Als we de coordinaten van de linkerbovenhoek van de rechthoek waarin de de hexagon past (x,y) noemen (in het voorbeeld is dat (0,0) voor de hexagon met de coordinaten (0,0) - merk op dat ik onderscheid maak tussen schermcoordinaten en coordinaten van de hexagonen!) zijn de punten de volgenden: { (x+b/2, y), (x+b,y+t), (x+b,y+h-t), (x+b/2,y+h), (x,y+h-t), (x,y+t) }. Ga even voor jezelf na dat dit klopt en hoe ze uit de tekening af te leiden zijn. Ik zou me kunnen vergissen, want ik schrijf ze nu even aan de hand van een schetsje op, dus laat even weten als je denkt dat er iets fout zit. Het berekenen van de pixelcoordinaten (x,y) is eenvoudig. Als px en py de coordinaten van de hexagonen zijn (zoals die dus op de tekening zijn genummerd), is dat voor even py (px*b,py*d) en voor oneven py (px*b+b/2,py*d). Voor de hexagon op positie (1,2) zijn die coordinaten dus bijvoorbeeld (40,68). (Dit kan je controleren door het plaatje in een tekenprogramma te openen). Dit valt voor alle coordinaten te generaliseren tot (px*b+(px%2)*(b/2),py*d), waarbij % de rest van een deling voorstelt (die ook in Java bestaat), zodat je voor alle hexagonen dezelfde formule kan toepassen.

Nu kan je dus de hexagonen tekenen. Je wilt ook, gegeven de pixelcoordinaten (x,y), kunnen bepalen op welke hexagoncoordinaten (px,py) geclicked is. Dit is aan de hand van de tekening ook wel uit te zoeken. We tekenen over elke hexagon een rechthoek (met een breedte b en een hoogte d), zoals ik al in de tekening aangegeven heb voor de eerste hexagon. We moeten weer onderscheid maken tussen even rijen en oneven rijen om te kunnen bepalen in welke rechthoek we ons bevinden. Voor even rijen is dit immers: (x/b, y/d) (waarbij / de deling met afronding omlaag is) en voor oneven rijen: ((x-b/2)/b, y/d). Dit is weer te generaliseren tot ((x-((y/d)%2)*(b/2))/b, y/d). Met deze formule kunnen we dus pixelcoordinaten omzetten in de coordinaten van de rechthoek waarin ze liggen. Deze formule is ook net door mij verzonnen dus kan ook niet correct zijn. Als je een fout denkt te zien, laat het me weten!

Helaas overlapt de rechthoek de hexagon waar 'ie bij hoort maar voor een deel. We moeten dus een uitzonderingssituatie bekijken. Eerst willen we daarvoor de relatieve pixelcoordinaten in de rechthoek weten. Dit gaat simpelweg door de eerdergenoemde coordinaten af te trekken van de pixelcoordinaten, aangezien we nu px en py weten: (x-(px*b+(px%2)*(b/2)),y-py*d). Merk op dat ik de formules gewoon van hierboven gekopieerd heb. Laten we de relatieve coordinaten (dx,dy) noemen.

Duidelijk is, dat we de tot nu toe gevonden (px,py) moeten aanpassen als we in een van de twee driehoekjes buiten de hexagon (in de linker- en rechtbovenhoek van de rechthoek) beland zijn. Dit is niet zo ingewikkeld te controleren aan de hand van de relatieve pixels ten opzichte van de linkerbovenhoek van de rechthoek, (dx,dy). De lijn van de linkerhoek is voorgesteld door y=t*(1-x/(b/2)) (controleer dit!) en de coordinaten liggen dus in de linkerhoek wanneer (py < t*(1-py/(b/2))). De formule voor de lijn van de rechterhoek is y=t*(x-(b/2))/(b/2) en de conditie van de rechterhoek is dan ook duidelijk. Beide formules zijn waarschijnlijk nog wel te vereenvoudigen of te herschrijven maar dat laat ik aan je eigen creativiteit over. Ik ben er ook niet van overtuigd dat ze correct zijn (en zo niet, laat 't dan even weten), als het idee maar duidelijk is.

Nu kun je dus vaststellen of de pixelcoordinaten in de hexagon liggen (in dat geval zijn de gevonden hexagoncoordinaten correct) of in een van de twee hoeken, in welk geval je de hexagoncoordinaten moet aanpassen. De y-coordinaat van de hexagon moet sowieso met 1 verlaagd worden, omdat je eigenlijk in een bovengelegen hexagon zit. Als je op een even rij zit, zul je alleen voor de linkerbovenhoek de x-coordinaat met 1 moeten verlagen. Als je in een oneven rij, zul je juist voor de rechterbovenhoek de x-coordinaat met 1 moeten verhogen. In beide andere gevallen blijft de x-coordinaat gelijk. Dit valt als volgt te generaliseren. Voor de linkerbovenhoek: (px-(1-py%2),py-1) en voor de rechterbovenhoek: (px+(py%2),py-1).

Merk op dat je, gegeven een recthoek, alleen hoeft te kijken naar het deel van de rechthoek dat niet bij de hexagon hoort. Het deel van de hexagon dat buiten de rechthoek valt, zal automatisch herleid kunnen worden doordat dit weer binnen de hoeken van de rechthoeken van de andere hexagonen valt. Verder zul je met deze methode altijd een set coordinaten terugkrijgen, maar deze hoeven niet geldig te zijn. Als je op pixel (1,1) klikt in het voorbeeld, zit je bijvoorbeeld buiten alle hexagonen en krijg je als hexagoncoordinaten (-1,-1) terug. Als je op (1,50) klikt krijg zit je naast de hexagon op positie (0,1) dus krijg je (-1,1). Dit is meestal geen probleem maar je moet er wel rekening mee houden.

Tot zover mijn analyse van het probleem. Alles is in één keer geschreven dus ik kan niet genoeg benadrukken dat er waarschijnlijk grove fouten in zitten. Aan de lezer om ze eruit te halen. Ik denk dat de basisideeën echter duidelijk genoeg zijn om met een basiskennis van de Java (AWT) componenten een werkende implementatie te maken.

edit:
Ok, als ik blokhaken in plaats van accolades om m'n lijst heenzet schijnt TOPIX in een oneindig lusje verzeilt te raken

[Soultaker]

Ik wil trouwens ook nog een keer regelmatige pentagrammen gebaseerd veld maken. Die moeten waarschijnlijk gecombineerd worden met andere vormen omdat ze op zichzelf niet tegelen zijn. Ik hou me aanbevolen voor suggesties voor vormen of berekeningen hiervoor.

[GAEvakYD]

WOWWWWWWWWWWWWWWWWWWWW, check die hulp.


Vet bedankt man , ik ga de hele avond stoeien. Nu moet het toch lukken, ik zal namelijk al te denken hoe ik die x-y coordinaten ging achterhalen enzo.

Thanks, je hoort nog van me