Diskuze: Kolize mezi ovály.
V předchozím kvízu, Online test znalostí Java, jsme si ověřili nabyté zkušenosti z kurzu.
Člen
Lubor Pešek:26.4.2016 18:13
Ty jo, ty komentáře je fakt děs psát, ale velmi důležité:)
No tak jestli chceš, můžeš se mrknout, jak jsem to udělal já. Rozhodně
nejsem spokojený se svým řešením pohybu, ale funguje to, jaks chtěl a je
to připravené na další rozšíření (více hadů, umělá inteligence,
okraje, bonusy, atd.)
Hlavní třída Prostredi, ve které se to odehrává, a která obsahuje
metodu main
import java.awt.Color;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Prostredi extends JFrame {
//###################-ATRIBUTY-###################
//==========KONSTANTNI ATRIBUTY TRIDY==========
//===========PROMENNE ATRIBUTY TRIDY===========
//========KONSTANTNI ATRIBUTY INSTANCI=========
//=========PROMENNE ATRIBUTY INSTANCI==========
private JFrame frame; //Hlavní okno programu, které i obsahuje KeyAdapter
private Had had; //Hlavička hada. Had nemá tělo, pouze hlavu (kdo chce, ať si to přejmenuje na hlavu:D)
private JPanel panel; //Panel, který je dobrý pouze na černé pozadí
//####################-STATIC-####################
//============STATICKY KONSTRUKTOR=============
//=========STATICKE PRISTUPOVE METODY==========
//==============STATICKE METODY================
//=================MAIN METODA=================
public static void main(String[] args) {
Prostredi prostredi = new Prostredi();
}
//###################-INSTANCE-###################
//=================KONSTRUKTOR=================
/**
* V konstruktoru metoda initt vytvoří herní prostředí, po kterém se bude
* had pohybovat. V konstruktoru se pouze inicializuje a nastaví had
* (později může být speciální metoda třeba vytvorHady() pro vytvoření více
* hadů) a spustí se jeho vlákno
*
*/
public Prostredi() {
initt();
had = new Had(panel);
panel.add(had);
had.setSize(10, 10);
had.setLocation(100, 30);
had.setPosun(0, 1);
had.start();
}
//=============PRISTUPOVE METODY===============
//===================METODY====================
private void initt() {
frame = new JFrame();
frame.setSize(500, 500);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel = new JPanel();
panel.setLayout(null); //nastavil jsem "žádný" layout, protože mi to mrcha špatně počítala
panel.setBackground(Color.black);
frame.add(panel);
frame.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent evt) {
if (evt.getKeyCode() == 39) {
doprava(); //metoda doprava zachycuje možné stavy a nastavuje nový vektor pohybu
} else if (evt.getKeyCode() == 37) {
doleva(); //stejně jako metoda doprava, tak i metoda doleva zachycuje možné stavy a nastavuje nový vektor pohybu
}
}
}
);
}
//###############-SOUKROME METODY-################
//=====STATICKE SOUKROME A POMOCNE METODY======
//==========SOUKROME A POMOCNE METODY==========
/**
* Ne příliš povedená definice otáčení hada je realizována pomocí metody
* doprava(). Nejdříve mě napadlo řešení otočení pomocí stavů, ale takto
* řešit jednu komponentu je ještě větší zločin, než switch-ovaná definice.
* Řešení pomocí switchů mi příjde procesorově úspornější, protože rozhodně
* nemusíme procházet všechny možné stavy a zrychlíme tak větvení.
*
* Metoda vždy zjistí hodnotu bývalé vektorové souřadnice X (zjišťuje to
* pomocí metody getPosunX()) a potom zjistí bývalou vektorovou souřadnici Y
* (kterou zjišťujeme podobnou metodou getPosunY()).
*
* Když metoda zjistí stav, ve kterém se právě had nachází, tak nastaví nové
* vektorové souřadnice, které otočí hada o 1 pixel "doprava"
*
*/
private void doprava() {
switch (had.getPosunX()) {
case -1:
switch (had.getPosunY()) {
case -1:
had.setPosun(0, -1);
break;
case 0:
had.setPosun(-1, -1);
break;
case 1:
had.setPosun(-1, 0);
}
break;
case 0:
switch (had.getPosunY()) {
case -1:
had.setPosun(1, -1);
break;
case 1:
had.setPosun(-1, 1);
}
break;
case 1:
switch (had.getPosunY()) {
case -1:
had.setPosun(1, 0);
break;
case 0:
had.setPosun(1, 1);
break;
case 1:
had.setPosun(0, 1);
}
}
}
/**
* Metoda doleva() má stejnou definici, jako metoda doprava, pouze otáčí na
* jinou stranu
*
*/
private void doleva() {
switch (had.getPosunX()) {
case -1:
switch (had.getPosunY()) {
case -1:
had.setPosun(-1, 0);
break;
case 0:
had.setPosun(-1, 1);
break;
case 1:
had.setPosun(0, 1);
}
break;
case 0:
switch (had.getPosunY()) {
case -1:
had.setPosun(-1, -1);
break;
case 1:
had.setPosun(1, 1);
}
break;
case 1:
switch (had.getPosunY()) {
case -1:
had.setPosun(0, -1);
break;
case 0:
had.setPosun(1, -1);
break;
case 1:
had.setPosun(1, 0);
}
}
}
//############-SOUKROME KONSTRUKTORY-#############
//===============SOUKROME TRIDY================
//==============TESTOVACI METODY===============
}Třída Had, u které ovádáš hlavičku
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JComponent;
import javax.swing.JPanel;
public class Had extends JComponent implements Runnable {
//###################-ATRIBUTY-###################
//==========KONSTANTNI ATRIBUTY TRIDY==========
//===========PROMENNE ATRIBUTY TRIDY===========
//========KONSTANTNI ATRIBUTY INSTANCI=========
private final JPanel panel; // Při vytváření nového hada ve Třídě Prostredi, předáváme hadovi panel, abychom na něj mohli vytvořit barieru z této třídy
//=========PROMENNE ATRIBUTY INSTANCI==========
private Thread vlakno;
private boolean jede = true; // Logickou proměnnou jede pouožíváme pro while cyklus, který zajišťuje pohyb hada vpřed. Pokud had narazí, proměnná zneguje a had zastaví
private int x, y; //proměnné x a y používá had pro práci s budoucí pozicí. Do proměnných se ukládají souřadnice, které představují krok, o který se had posune (hodnoty nabývají od -1 do 1)
//####################-STATIC-####################
//============STATICKY KONSTRUKTOR=============
//=========STATICKE PRISTUPOVE METODY==========
//==============STATICKE METODY================
//=================MAIN METODA=================
//
// public static void main(String[] args) {
// new Had();
// }
//###################-INSTANCE-###################
//=================KONSTRUKTOR=================
/**
* V konstruktoru hada pouze předáme panel a pak s ním můžeme pracovat:)
*
* @param panel // panel představuje plátno ze třídy Prostredi, na které
* vykreslujeme hada a barieru
*/
Had(JPanel panel) {
this.panel = panel;
}
//=============PRISTUPOVE METODY===============
/**
* Návratová metoda getPosunY() vrací hodnotu, o kterou se had posune vpřed
* po souřadnici Y
*
* @return y //y představuje hodnotu, o kterou se had posune po Y-nové
* souřadnici
*/
public int getPosunY() {
return y;
}
/**
* Návratová metoda getPosunY() vrací hodnotu, o kterou se had posune vpřed
* po souřadnici X
*
* @return x //x představuje hodnotu, o kterou se had posune po X-nové
* souřadnici
*/
public int getPosunX() {
return x;
}
//===================METODY====================
/**
* Paint(Graphics) metoda je zděděná metoda třídy JComponent a díky ní
* nakreslíme hlavičku hada a nstavíme mu barvu
*
* @param g
*/
@Override
public void paint(Graphics g) {
super.paint(g);
g.setColor(Color.yellow);
g.fillOval(0, 0, 10, 10);
}
/**
* Vláknovou třídu run používáme pro pohyb hada. Obsahuje while cyklus,
* který běží dokud had nenarazí, což hlídá metoda getComponentAt(x,y),
* která nám zjišťuje, co je "pod námy". Jestli hodnota null, nenarazili
* jsme, jestli nějaké jméno, narazili jsme a rozbili si hubu
*/
@Override
public void run() {
while (jede) {
try {
Thread.sleep(30); //prodleva, která určuje rychlost hada (nedoporučuju nastavovat na hodnotu 1 :D)
Bariera bariera = new Bariera(Color.blue); // při každém pohybu hada vytváříme novou barieru. Bariera je jeden oválek o velikosti hlavy hada a tím způsobuje, že had roste
panel.add(bariera); //díky předanému panelu můžeme i v této třídě kreslit na panel třídy Prostredi
bariera.setSize(10, 10);
bariera.setLocation(getX(), getY());
bariera.setName("BOOM"); //já a moje názvy:D prostě bariera musí obsahovat nějaký název:) když bariera nemá název (takže má null název) tak přes ní had může přejet
/**
* důležitá podmínka, která nám zjišťuje, jestli had narazil
* nebo ne. Zjišťujeme budoucí pozici (nebo můžeme zjišťovat
* aktuální pozici s tím, že had se do bariery/zdi "zaboří")
*/
if (panel.getComponentAt(getX() + getPosunX(), getY() + getPosunY()).getName() != null) {
jede = false;
}
setLocation(getX() + getPosunX(), getY() + getPosunY()); //posun hada
} catch (InterruptedException ex) {
}
}
}
public void start() {
if (vlakno == null || !vlakno.isAlive()) {
vlakno = new Thread(this);
vlakno.start();
}
}
/**
* Metodu setPosun používáme v tlačítku ve třídě Prostredi a díky ní
* nastavíme změnu pohybu. Určíme vektorové souřadnice, kterými se má had
* vydat z aktuální pozice
*
* @param x //nová vektorová souřadnice X
* @param y //nová vektorová souřadnice Y
*/
public void setPosun(int x, int y) {
this.x = x;
this.y = y;
}
//###############-SOUKROME METODY-################
//=====STATICKE SOUKROME A POMOCNE METODY======
//==========SOUKROME A POMOCNE METODY==========
//############-SOUKROME KONSTRUKTORY-#############
//===============SOUKROME TRIDY================
//==============TESTOVACI METODY===============
}No a třída Bariera, která slouží jako hadův ocásek
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JComponent;
public class Bariera extends JComponent {
//###################-ATRIBUTY-###################
//==========KONSTANTNI ATRIBUTY TRIDY==========
//===========PROMENNE ATRIBUTY TRIDY===========
//========KONSTANTNI ATRIBUTY INSTANCI=========
private final Color color; //Díky tomu, že máme proměnnou color a inicializujeme ji v konstruktoru, tak můžeme v každém novém hadovi nastavovat barvu jeho ocásku.
//=========PROMENNE ATRIBUTY INSTANCI==========
//####################-STATIC-####################
//============STATICKY KONSTRUKTOR=============
//=========STATICKE PRISTUPOVE METODY==========
//==============STATICKE METODY================
//=================MAIN METODA=================
//
// public static void main(String[] args) {
// new Bariera();
// }
//###################-INSTANCE-###################
//=================KONSTRUKTOR=================
/**
* V konstruktoru předáváme barvičku pro hadův ocásek:)
*
* @param barva //barva, kterou bude mít hadův ocásek
*/
Bariera(Color barva) {
color = barva;
}
//=============PRISTUPOVE METODY===============
//===================METODY====================
/**
* Třída bariera se používá jenom proto, aby udělala hadovi ocásek:)
*
* @param g //Grafický parametr, který předáváme automaticky metodě předka
* paint(g);
*/
@Override
public void paint(Graphics g) {
super.paint(g);
g.setColor(color);
g.fillOval(0, 0, 10, 10);
}
//###############-SOUKROME METODY-################
//=====STATICKE SOUKROME A POMOCNE METODY======
//==========SOUKROME A POMOCNE METODY==========
//############-SOUKROME KONSTRUKTORY-#############
//===============SOUKROME TRIDY================
//==============TESTOVACI METODY===============
}Pokud by někoho napadlo lepší řešení toho otáčení, tak sem s ním
rád se přiučím. (mě totiž nic lepšího nenapadá:( )
Jinak jediné, co se mi v rychlosti nepodařilo debugnout, tak je "žádná"
prodlevá při držení tlačítek v metodě keyPressed(KeyEvent). Zatím jsem
neměl důvod tuto prodlevu řešit - ve svých programech jsem nedržel
tlačítka, pouze stiskl:) ale jdu se na to podívat, jak se to dělá.
Akceptované řešení
+20 Zkušeností
+2,50 Kč
+20 Zkušeností
+2,50 Kč
Lubor Pešek:28.4.2016 0:47
trošku mě připomínáš
jednoho z mojich šéfů:D neumí programovat, tak ho povýšili, aby nám do
toho nekecal. Největší hlod, co z něj teď vylezlo, byl jeho návrh na
rozhraní třídy.
"Kód bude obsahovat 200 řádků, tak" a ten vůl navrhl, že budou bohatě
stačit dvě metody.... Takových teoretiků je plná prdel.
Divej, ukončíme to, protože nadpis topicu je o pomoci se stavem, kdy had
narazí. To je vyřešeno a toto už je jen flame. Prostě já dělám třeba
až moc komentářů, je to můj problém, až mi to nařídí šéf, že to
chce stručněji, tak se podřídím. Vy byste mě za to vykleštili už teď.
Hotovo tečka, kašlem na to jo? nebo kdyžtak si dáme sraz a zajdem na pívko
(teda v mém případě kofču, su abstinent;) ).
Zobrazeno 23 zpráv z 23.