TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
tu knihovnu tu nemám :-/ kde jí najdu prosím
?? :-)
Příspěvky odeslané z IP adresy 89.176.108.–
Honza
Honza
ten tam nemám, to je systemový soubor?? v tom je co? :-)
Honza
Ahoj mam problém s převodem hry Dáma z JBuilderu do vývojového prostředí NetBeans. Hlásí mi to pořád chyby a nevím co s tím, mohl by jste se na to někdo kouknout aby to šlapalo?? Děkuju mooc :-) nechce mi to vykreslovat pole ... zdrojový kód zde
import sugar.Sys;
public class Dama {
// hraci pole
final static int sirka = 8; // a .. h (zleva doprava)
final static int vyska = 8; // 1 .. 8 (zdola nahoru)
static char[][] pole = new char[sirka][vyska];
// znaky, pouzite v hracim poli
final static char znakNic = '.'; // volne policko
final static char znakJa1 = 'j'; // jeden kamen hrace
final static char znakJa2 = 'J'; // dva kameny (dama) hrace
final static char znakPC1 = 'p'; // jeden kamen pocitace
final static char znakPC2 = 'P'; // dva kameny (dama) pocitace
///////////////////////////////////////////////////////////////////////////////
// metoda, ktera nasadi vsechny kameny na hraci pole
static void nasadit() {
for (int i = 0; i < sirka; i++)
for (int j = 0; j < vyska; j++)
pole[i][j] = znakNic;
for (int i=0; i<sirka/2; i++) {
pole[i * 2 ][0] = znakJa1;
pole[i * 2 + 1][1] = znakJa1;
pole[i * 2 ][2] = znakJa1;
pole[i * 2 + 1][vyska - 1] = znakPC1;
pole[i * 2 ][vyska - 2] = znakPC1;
pole[i * 2 + 1][vyska - 3] = znakPC1;
}
}
///////////////////////////////////////////////////////////////////////////////
// funkce, ktera zjisti, zda na zadanych souradnicich je kamen hrace
static boolean jeZnakJa(int x, int y) {
return (pole[x][y] == znakJa1) || (pole[x][y] == znakJa2);
}
///////////////////////////////////////////////////////////////////////////////
// funkce, ktera zjisti, zda na zadanych souradnicich je kamen pocitace
static boolean jeZnakPC(int x, int y) {
return (pole[x][y] == znakPC1) || (pole[x][y] == znakPC2);
}
///////////////////////////////////////////////////////////////////////////////
// funkce ktera prevede souhradnice na retezec
static String tahNaString(int x1, int y1, int x2, int y2) {
return "" +
(char) (x1 + 'a') + (char) (y1 + '1') + " " +
(char) (x2 + 'a') + (char) (y2 + '1');
}
///////////////////////////////////////////////////////////////////////////////
// metoda, ktera zobrazi hraci pole
static void zobraz() {
for (int j = vyska - 1; j >= 0; j--) {
Sys.p(' ');
Sys.p(j+1);
for (int i = 0; i < sirka; i++) {
Sys.p(' ');
if (i % 2 == j % 2) // zobrazim pouze pole, na kterych se hraje
Sys.p(pole[i][j]);
else
Sys.p(" "); // na ostatnich pozicich je mezera
}
Sys.pln();
}
Sys.p(" ");
for (int i = 0; i < sirka; i++) {
Sys.p(' ');
Sys.p((char) (i + 'a'));
}
Sys.pln();
}
///////////////////////////////////////////////////////////////////////////////
// funkce signum (znamenko)
static int signum(int x) {
if (x < 0) return -1;
if (x > 0) return 1;
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// funkce, ktera zkontroluje, zdaje zadany tah napsany spravne (syntaxi) a
// zda je mozne tento tah provest. Pokud ne, vrati hodnotu 0. Pokud ano,
// vrati ciselnou hodnotu, predstavujici vyhodnost tohoto tahu (napr.
// vyhozeni damy predstavuje vyhodnost 10, vyhozeni kamene = 1).
static int zkontrolujTah(boolean hrajePC, String tah) {
// prevedu retezec na ciselne souradnice
if (tah.length() != 5)
return 0;
int x1 = tah.charAt(0) - 'a';
int y1 = tah.charAt(1) - '1';
int x2 = tah.charAt(3) - 'a';
int y2 = tah.charAt(4) - '1';
// kontrola rozsahu zadanych souradnic,
// zda je volne ciloveho pole
// a zda tah probiha po diagonale
if (x1 < 0 || y1 < 0 || x1 >= sirka || y1 >= vyska || // tah - odkud
x2 < 0 || y2 < 0 || x2 >= sirka || y2 >= vyska || // tah - kam
pole[x2][y2] != znakNic || // cilove pole musi byt volne
(x2 - x1 != y2 - y1 && x2 - x1 != y1 - y2)) // tah po diagonale
return 0;
// kontrola: kdo hraje? (hrac / pocitac)
if ((hrajePC && !jeZnakPC(x1, y1)) || (!hrajePC && !jeZnakJa(x1, y1)))
return 0;
// tah jednoduchym kamenem
if (pole[x1][y1] == znakJa1 || pole[x1][y1] == znakPC1) {
// vyhodne je vytvorit si damu (tak, ze dojdu na konec hraciho pole)
int vyhodnost = 0;
if ((hrajePC && y2 == 0) || (!hrajePC && y2 == vyska - 1))
vyhodnost = 10;
// pouhy posun o jeden dilek (po diagonale)
if ((!hrajePC && y2 == y1 + 1) || (hrajePC && y2 == y1 - 1))
return 1 + vyhodnost;
// vyhozeni kamene protihrace
if ((!hrajePC && y2 == y1 + 2) || (hrajePC && y2 == y1 - 2)) {
char coVyhazuji = pole[(x1 + x2) / 2][(y1 + y2) / 2];
if (hrajePC) {
if (coVyhazuji == znakJa1)
return 2 + vyhodnost;
if (coVyhazuji == znakJa2)
return 11 + vyhodnost;
}
else {
if (coVyhazuji == znakPC1)
return 2 + vyhodnost;
if (coVyhazuji == znakPC2)
return 11 + vyhodnost;
}
}
}
// tah dvojitym kamenem (damou)
if ((pole[x1][y1] == znakJa2 || pole[x1][y1] == znakPC2) && x1 != x2) {
int smerX = signum(x2 - x1);
int smerY = signum(y2 - y1);
int vzdalenost = (x2 - x1) * smerX;
int vyhodnost = 1;
for (int i = 1; i < vzdalenost; i++) {
int x = x1 + i * smerX;
int y = y1 + i * smerY;
// zadny hrac nemuze vyhazovat sam sebe
if ((hrajePC && jeZnakPC(x, y)) || (!hrajePC && jeZnakJa(x, y)))
return 0;
// ohodnotim vyhozeny kamen
if (pole[x][y] == znakPC1 || pole[x][y] == znakJa1)
vyhodnost += 1;
if (pole[x][y] == znakPC2 || pole[x][y] == znakJa2)
vyhodnost += 10;
}
return vyhodnost;
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// metoda, ktera provede zadany tah
static void provedTah(String tah) {
int x1 = tah.charAt(0) - 'a';
int y1 = tah.charAt(1) - '1';
int x2 = tah.charAt(3) - 'a';
int y2 = tah.charAt(4) - '1';
pole[x2][y2] = pole[x1][y1];
if (y2 == 0 && pole[x2][y2] == znakPC1)
pole[x2][y2] = znakPC2; // vytvorim damu pocitace
if (y2 == vyska - 1 && pole[x2][y2] == znakJa1)
pole[x2][y2] = znakJa2; // vytvorim damu lidskeho hrace
int smerX = signum(x2 - x1);
int smerY = signum(y2 - y1);
int vzdalenost = (x2 - x1) * smerX;
for (int i = 0; i < vzdalenost; i++)
pole[x1 + i * smerX][y1 + i * smerY] = znakNic;
}
///////////////////////////////////////////////////////////////////////////////
// metoda, ktera najde nejvyhodnejsi tah (vyhozeni damy, vyhozeni kamene...)
static String nejlepsiTah(boolean pocitace) {
int nejVyhodnost = 0;
String nejTah = "";
for (int x1 = 0; x1 < sirka; x1++)
for (int y1 = 0; y1 < vyska; y1++)
if ((pocitace && jeZnakPC(x1, y1)) || (!pocitace && jeZnakJa(x1, y1)))
for (int x2 = 0; x2 < sirka; x2++)
for (int y2 = 0; y2 < vyska; y2++) {
String tah = tahNaString(x1, y1, x2, y2);
int vyhodnost = zkontrolujTah(pocitace, tah);
if (vyhodnost > nejVyhodnost ||
// pokud je nekolik tahu stejne vyhodnych, vybiram nahodne
(vyhodnost == nejVyhodnost && vyhodnost > 0 && Math.random() < 0.25) ) {
nejVyhodnost = vyhodnost;
nejTah = tah;
}
}
return nejTah;
}
///////////////////////////////////////////////////////////////////////////////
// hlavni metoda
public static void main(String[] args) {
// nasadim kameny na vychozi pozice
nasadit();
// cyklus jednotlivych tahu
while (true) {
// zobrazim hraci pole
Sys.pln();
zobraz();
Sys.pln();
// prectu z klavesnice tah hrace a provedu jej
String tah;
while (true) {
// nactu z klavesnice tah hrace
Sys.p("Zadejte tah (napr. 'a2 b3' nebo 'auto'): ");
tah = Sys.readLine().toLowerCase(); // velka pismena prevedu na mala
// vygeneruji automaticky tah
if (tah.compareTo("auto") == 0) {
tah = nejlepsiTah(false);
Sys.pln();
if (tah.length() == 0)
Sys.pln("Nemuzete tahnout zadnym kamenem! PROHRAL JSTE.");
else
Sys.pln("Automaticky tah: " + tah);
}
// konec hry
if (tah.length() == 0) break;
// provedu zadany tah
if (zkontrolujTah(false, tah) > 0) {
provedTah(tah);
break;
}
}
// konec hry
if (tah.length() == 0) break;
// zobrazim hraci pole
Sys.pln();
zobraz();
Sys.pln();
// najdu nejvyhodnejsi tah pocitace
tah = nejlepsiTah(true);
// pocitac jiz nemuze tahnout => konec
if (tah.length() == 0) {
Sys.pln("Pocitac nemuze tahnout zadnym kamenem. VYHRAL JSTE.");
break;
}
// zobrazim a provedu tah pocitace
Sys.pln("Tah pocitace: " + tah);
provedTah(tah);
}
// konec hry
Sys.pln();
Sys.pln("===== KONEC =====");
}
}
