katsoin tuolta java docseista mutta en löytänyt mitään apua, millä luetaan Scanner:illa char arvoja?
Yleensä merkki kerrallaan lukemiseen kannattaa käyttää esimerkiksi InputStreamReaderia.
Scannerillakin tämä onnistuu esimerkiksi asettamalla haluttujen merkkijonojen erottimeksi tyhjän merkkijonon (kun oletuksena on tyhjiä merkkejä sisältävä merkkijono (whitespace)).
Scanner s = new Scanner("hfeih oeia haaoa oeo");
s.useDelimiter("");
while(s.hasNext()) {
System.out.println(s.next());
}Ja jos on tarvetta saada nimenomaan char, eikä yhden merkin pituinen String, niin s.next().charAt(0), mutta etenkin tässä tapauksessa suosittelen käyttämään Readereita.
kiitos neuvosta, otin tuon s.next().charAt(0) jutun ja toimii hyvin...
tuota taas tarvitsin kun tein yksinkertaisen merkkigrafiikka labyrinttipelin jossa käytän switch- lausetta koska String ei toimi switch:in kanssa
öö.. en oikein tiedä että mitä eroa noilla Readereilla on eroa?
Siis Scanneriin verrattuna
PS: okei miten noita kiellettyjä koordinaatteja määritellään ei symmetrisessä char- taulukossa? kun tuota peliä ajattelin...
PS: tein tämmöisen Asciipelin, jossa toimii ääkköset(ö:n ASCII- arvo on mukamas 8221)
import java.util.Scanner;
public class Taulupeli {
public static Scanner Lue = new Scanner(System.in);
public static void main(String[] args) {
final int KOKO = 20;
char[][] taulu = new char[KOKO][KOKO];
int aakkonen = 8221;
int liikkeet = 10;
char ukko = 'X';
char liike = ' ';
char omena = 'O';
int omena_x = 0;
int omena_y = 0;
int omenat = 0;
int kokonaisliike = 0;
char merkki = (char)aakkonen;
char tyhja = ' ';
boolean
// täytetään taulukko merkeillä
for (int i=0; i<KOKO; i++) {
for (int j=0; j<KOKO; j++) {
taulu[i][j] = merkki;
if (i != 0 && i != KOKO -1) {
if (j > 0 && j < KOKO-1)
taulu[i][j] = tyhja;
}
}
}
// määritellään omena
omena_x = 1 + (int)((KOKO-2)*Math.random());
omena_y = 1 + (int)((KOKO-2)*Math.random());
// merkitään omenan paikka
taulu[omena_x][omena_y] = omena;
// merkitään ukon paikka
int x = KOKO/2;
int y = KOKO/2;
taulu[x][y] = ukko;
// piirretään taulukko
while (liikkeet > 0 && lopetus) {
for (int i=0; i<KOKO; i++) {
for (int j=0; j<KOKO; j++) {
System.out.print(taulu[i][j]);
if (j == KOKO-1) System.out.print("\n");
}
}
// Luetaan siirrot
try {
liike = Lue.nextLine().charAt(0);
--liikkeet;
++kokonaisliike;
} catch (Exception e) {}
if (liike != 'w' && liike != 'a' && liike != 's' && liike != 'd') {
++liikkeet;
--kokonaisliike;
}
// siirrytään
switch(liike) {
case 'w': // ylös
taulu[x][y] = tyhja; // ukko poistetaan
x--;
if ( x == 0 ) x = KOKO-2;
taulu[x][y] = ukko; // määritellään uusi ukon paikka
break;
case 's': // alas
taulu[x][y] = tyhja;
x++;
if ( x == KOKO-1 ) x = 1;
taulu[x][y] = ukko;
break;
case 'a': // vasen
taulu[x][y] = tyhja;
y--;
if ( y == 0 ) y = KOKO-2;
taulu[x][y] = ukko;
break;
case 'd': // oikea
taulu[x][y] = tyhja;
y++;
if ( y == KOKO-1 ) y = 1;
taulu[x][y] = ukko;
break;
case 'K': liikkeet = 0;
break;
default: System.out.println("Virhe");
break;
}
if (x == omena_x && y == omena_y) {
omenat++;
taulu[x][y] = ukko;
// määritellään omena
omena_x = 1 + (int)((KOKO-2)*Math.random());
omena_y = 1 + (int)((KOKO-2)*Math.random());
liikkeet += 10;
// merkitään omenan paikka
taulu[omena_x][omena_y] = omena;
}
} System.out.println("Söit "+omenat+" omenaa ja siirryit "+kokonaisliike+" kertaa ja sinulle jäi "+liikkeet+" siirtoa");
}
}Tommittaja kirjoitti:
ö:n ASCII- arvo on mukamas 8221
Mistä olet tuollaista keksinyt? ö:llä ei ole ASCII-arvoa, koska se ei kuulu ASCII-merkistöön. En myöskään huomaa koodissasi mitään funktiota, jolla käskisit käsitellä ASCII-arvoja. Castaat kyllä kokonaisluvun 8221 chariksi, mutta ko. castaus ei ole mitenkään rajoittunut ASCII-merkistöön.
jaa... eikös tuo eksplisiittinen tyyppimuunnos kerro sitä ihan normaalisti(tiedän kyllä että ascii merkistö rajoittuu 128)
PS: osaatko muuten tuota oikeata ongelmaani? siis "laittaa kiellettyjä koordinaatteja epäsymmetriseen char taulukkoon"?
Tommittaja kirjoitti:
jaa... eikös tuo eksplisiittinen tyyppimuunnos kerro sitä ihan normaalisti(tiedän kyllä että ascii merkistö rajoittuu 128)
char merkki = 'ö';
Char ei rajoitu 8 bittiin vaan voi sisältää unicode-merkkejä.
aijaa.. hyvä tietää, mutta osaatko vastata tuohon char:in kielletty koordinaatti kysymykseen?
Tommittaja kirjoitti:
PS: osaatko muuten tuota oikeata ongelmaani? siis "laittaa kiellettyjä koordinaatteja epäsymmetriseen char taulukkoon"?
Mitä tarkoitat termillä epäsymmetrinen char taulukko? Millä tavalla koordinaatit ovat kiellettyjä?
EDIT typoja.
esim tällainen labyrintti;
########## # # # # # # # # # # # # # # # # # # # # # ##########
ja noiden ruutujen läpi ei pääse..
Tommittaja kirjoitti:
PS: osaatko muuten tuota oikeata ongelmaani? siis "laittaa kiellettyjä koordinaatteja epäsymmetriseen char taulukkoon"?
Alkuperäisessä kysymyksessä se taisi olla symmetrinen, mutta eipä sillä ole vastauksen kannalta merkitystä.
Koska kyseessä näyttää olevan char taulukko, niin loogisimmalta tuntuisi että päätät mikä merkki tarkoittaa "kiellettyä", ja sitten vaan lätkit ko. taulukkoon haluamiisi koordinaatteihin sitä merkkiä.
Eli esimerkkisi mukaisessa tapauksessa '#' voisi olla kielletty merkki, niin esimerkiksi koordinaattii 0,0 saat # merkin
taulu[0][0] = '#';
jaa.. mietin sitä kyllä, mutta sitten sain jostain mieleeni, että sitä ei voi tehdä.. :D
PS: eikö tuon voisi tehdä vain näin:
char[3][3] = {{'#','#','#'},{'#',' ','#'},{'#','#','#'}}tuosta nyt tulee tämmöinen:
### # # ###
Edit: ei tule mieleen, miten merkitsen jokun tietyn merkin kielletyksi? :D
Tuo ei toimi.. miten nuo sitten asetetaan?
miksi tässä taulukossa tulee joku [[C@e48e1b ennen taulukkoa?
public class Taulutesti {
public static void main(String[] args) {
char[][] taulu = new char[3][3];
taulu[0][0] = '#';
taulu[0][1] = '#';
taulu[0][2] = '#';
taulu[1][0] = '#';
taulu[1][1] = ' ';
taulu[1][2] = ' ';
taulu[2][0] = '#';
taulu[2][1] = '#';
taulu[2][2] = '#';
System.out.println(taulu);
for (int i=0; i<3; i++) {
for (int j=0; j<3; j++) {
System.out.print(taulu[i][j]);
if (j == 3-1) System.out.print("\n");
}
}
}
}System.out.println(taulu);
Tässä tulostat taulukko-olion, jonka toString()-metodin toteutus palauttaa taulukon osoitteen muistissa, siis juurikin tuon "e48e1b":n.
mitä siis teen? ja miten voi kirjoittaa yksinkertaisemmin char-taulukon sisällön?
PS: sain toimimaan näin:
public class Taulutesti {
public static void main(String[] args) {
char[][] taulu = new char[3][3];
taulu[0][0] = '#';
taulu[0][1] = '#';
taulu[0][2] = '#';
taulu[1][0] = '#';
taulu[1][1] = ' ';
taulu[1][2] = ' ';
taulu[2][0] = '#';
taulu[2][1] = '#';
taulu[2][2] = '#';
for (int i=0; i<3; i++) {
for (int j=0; j<3; j++) {
System.out.print(taulu[i][j]);
if (j == 3-1) System.out.print("\n");
}
}
}
}mutta onko siis mitään yksinkertaisempaa tapaa merkitä merkit taulukkoon >>epäsymmetrisesti<<
Jos taulukon ensimmäinen indeksi on tarkoitus tulkita vaaka- tai toinen pystykoordinaattina, siirrä j-silmukka ulommaiseksi:
for (int j = 0; j < 3; j++) {
for (int i = 0; i < 3; i++) {
System.out.print(taulu[i][j]);
}
System.out.println();
}Aloita nyt vaikka aluksi määrittelemällä, mitä sinulle tarkoittaa "epäsymmetrinen".
Kumpikin mainitsemasi tapa määritellä taulukko onnistuu kyllä eikä kumpikaan tapa aseta rajoitteita tai vaatimuksia taulukon (epä)symmetrisyydelle:
char[3][3] = {{'#','#','#'},{'#',' ','#'},{'#','#','#'}};char[][] taulu = new char[3][3];
taulu[0][0] = '#';
taulu[0][1] = '#';
taulu[0][2] = '#';
taulu[1][0] = '#';
taulu[1][1] = ' ';
taulu[1][2] = ' ';
taulu[2][0] = '#';
taulu[2][1] = '#';
taulu[2][2] = '#';tarkoitin juuri epäsymmetrisellä, että talukkoa ei määritellä tällä tavalla:
for (int i=0; i<KOKO; i++) {
for (int j=0; j<KOKO; j++) {
taulu[i][j] = merkki;
if (i != 0 && i != KOKO -1) {
if (j > 0 && j < KOKO-1)
taulu[i][j] = tyhja;
}
}
}vaan näin:
char[3][3] = {{'#','#','#'},{'#',' ','#'},{'#','#','#'}};mutta minulla ei toiminut tämä esimerkki..
PS: siis miten asetetaan jokin tietty merkki kielletyksi?
Päätät mikä merkki on kielletty ja sitten tarkistat onko solussa juuri se päättämäsi merkki ja jos on niin käsittelet kielletyn tilanteen.
Ei taulukossa itsessään ole vakiona mitään metodia, jolla voisi määritellä jonkin tietyn arvon "kielletyksi". Toki voit tehdä itse vaikka taulukoluokan joka viskoo poikkeuksen jos yrität sijoittaa taulukkoon kiellettyä merkkiä, lukea sitä tai ihan mitä tahansa keksitkin.
tuo
char[3][3] = {{'#','#','#'},{'#',' ','#'},{'#','#','#'}};ei toimi minulla :(
Tommittaja kirjoitti:
char[3][3] = {{'#','#','#'},{'#',' ','#'},{'#','#','#'}};mutta minulla ei toiminut tämä esimerkki..
Epähuomiossa vaan kopioin tuon sinun laittaman syntaksin, mutta sen siis tietenkin kuuluisi olla näin
char[][] taulu = {{'#','#','#'},{'#',' ','#'},{'#','#','#'}};ahaa, eli määritellään taulukon koko vasta täyttäessä..
toimii!
Joo, plus että siitä puuttui se taulukon nimi (taulu) kokonaan.
Samalla tavallahan se koko määritellään =-merkin oikealla puolella tuossa toisessakin tapauksessa.
tuosta minun labyrinttipelistä(tulee myös vihuja) tulee konsoliohjelma, elikkä näppäimet wasd pitää painaa ENTER - joka siirron lähettämiseen, kun en ihan noin pitkällä ole(siis missään KeyListenereissä)
Tommittaja kirjoitti:
tarkoitin juuri epäsymmetrisellä, että talukkoa ei määritellä tällä tavalla:
for (int i=0; i<KOKO; i++) { for (int j=0; j<KOKO; j++) { taulu[i][j] = merkki; if (i != 0 && i != KOKO -1) { if (j > 0 && j < KOKO-1) taulu[i][j] = tyhja; } } }vaan näin:
char[3][3] = {{'#','#','#'},{'#',' ','#'},{'#','#','#'}};
Kukaan ei oikein voi ottaa sinua tosissaan kohta, koska kumpikaan esittämäsi tapa ei määrittele taulukkoa tai tee siitä symmetristä / epäsymmetristä. Molemmissa tavoissa ainoastaan täytetään jo edellä määritelty taulukko esim.
/* Määrittely */ int taulu[KOKO];
sori pieni typovirhe.. tarkoitin tietenkin taulukon täyttöä... :D
Edit: ja hei olen harjoitellut javaa, tai ylipäätäänsä mitään ohjelmointikieltä nyt 2 kuukautta, joten et voi olettaa että olen täydellinen.
Tommittaja kirjoitti:
sori pieni typovirhe.. tarkoitin tietenkin taulukon täyttöä... :D
Edit: ja hei olen harjoitellut javaa, tai ylipäätäänsä mitään ohjelmointikieltä nyt 2 kuukautta, joten et voi olettaa että olen täydellinen.
En ole mielestäni olettanut sinun olevan täydellinen, mutta pientä omatoimisuutta voisi harrastaa noiden apujen pyytämiseen. Javan dokumentaatio on varsin kattava, jota kannattaa jatkossakin lukea. Sinulle on tarjottu valtavasti apua koodiesi kanssa, joten mielestäni on kohtuullista olettaa tietämyksen kasvavan. Samojen asioiden selittäminen vain on melko turhauttavaa.
Voisit ainakin kokeilla metabolixin ideaa kirjata paperille ruudukkoon ohjelmasi muuttujat, sekä niiden arvot jokaisen koodirivin jälkeen. Samoin pinotehtävä on helpohko tapa oppia silmukoita ja muita ohjelmoinnissa tärkeitä asioita.
hmm.. en kyllä tiedä, mikä noissa pinoissa on ajatuksena? ja juuri tuo return; osa tuossa on vaikea: palauttaa arvonaan viimeisimmän muuttujan?
Kuvitellaampa, että haluat palata samaa reitiä, jota olet kulkenut. Lisäät tietorakenteeseen (pino) jokaisen kadun nimen. Perillä ollessasi pääset takaisin alkuun helposti seuraamalla tallentamiasi katuja.
reitti Pino(); /* Aloitetaan */ reitti.push( tie1 ); reitti.push( tie2 ); reitti.push( tie3 ); reitti.push( tie4 ); reitti.push( tie5 ); reitti.push( tie6 ); /* Kohde */ /* Peruutetaan */ reitti.pop() /* tie6 */ reitti.pop() /* tie5 */ reitti.pop() /* tie4 */ reitti.pop() /* tie3 */ reitti.pop() /* tie2 */ reitti.pop() /* tie1 */ /* Alussa */
Soveltamalla tuota ajatusta pinon tarkoituksen tulisi selvitä.
Tommittaja kirjoitti:
hmm.. en kyllä tiedä, mikä noissa pinoissa on ajatuksena?
Eikö se kolikkovertaus ollut riittävän havainnollinen? Voithan toki ajatella, että kirjoitat aina siihen vaikka haluamasi kirjaimen siihen pinoon laittamaasi kolikkoon niin sitten kun otat sen kolikon pinosta, niin saat sen kirjaimen, jonka viimeksi olet sinne pinoon "tallettanut". Lähtökohtaisesti se on tietorakenne, jota käytetään LIFO-tyylisesti (Last in, first out eli viimeisimpänä sijoitettu ensimmäisenä ulos) Ja tuossa Teuro kirjoittikin käytännön esimerkikin.
Liittyikö tämä jotenkin pinoon, vai onko erillisestä asiasta kysymys:
Tommittaja kirjoitti:
ja juuri tuo return; osa tuossa on vaikea: palauttaa arvonaan viimeisimmän muuttujan?
Jos ei liittynyt, niin return palauttaa yksinkertaisesti sen arvon, joka sen käsketään palauttaa, ei välttämättä "viimeisintä muuttujaa".
kyllä, liittyi asiaan, jos katsot tuota Metabolixin viestiä, siinä sanotaan:
Täydennä: metodi palauttaa arvonaan viimeisimmän arvon(jotain sinne päin)
Tommittaja kirjoitti:
kyllä, liittyi asiaan, jos katsot tuota Metabolixin viestiä, siinä sanotaan:
Täydennä: metodi palauttaa arvonaan viimeisimmän arvon(jotain sinne päin)
Metodi palauttaa juuri sen arvon, jonka käsket sen palauttaa.
#include <iostream>
using namespace std;
int annaArvo( int a ){
return a; /* Palauttaa a:n arvon */
}
int main(){
int b = 7;
int c = 2;
cout << annaArvo( 3 ) << endl; /* tulostaa 3 */
cout << annaArvo( b ) << endl; /* tulostaa 7 */
cout << annaArvo( c ) << endl; /* tulostaa 2 */
system("Pause");
return 0; /* Palauttaa 0 */
}Tommittaja kirjoitti:
kyllä, liittyi asiaan, jos katsot tuota Metabolixin viestiä, siinä sanotaan
Joo en taas valitettavasti arvannut että viitattiin jossakin toisessa threadissa olevaan viestiin, vaikka edellinen puhuikin jo metabolixista.
Tommittaja kirjoitti:
kyllä, liittyi asiaan, jos katsot tuota Metabolixin viestiä
... joka tosin on toisessa aiheessa. Nyt järki käteen ja edes viestit oikeaan paikkaan.
hmm... minkä arvon noista tuo teuron viesti palauttaa, return 0;??
Tommittaja kirjoitti:
hmm... minkä arvon noista tuo teuron viesti palauttaa, return 0;??
Täh?
Se palauttaa luvun 0. Olet ehkä nollasta joskus koulussa kuullut?
Tommittaja kirjoitti:
hmm... minkä arvon noista tuo teuron viesti palauttaa, return 0;??
Teuron viestin esimerkissä on kaksi metodia, joista toinen palauttaa a:n arvon ja toinen palauttaa luvun 0. Ja nämä arvot palautetaan kohtaan, jossa metodia on kutsuttu.
JA huom! Teuron viesti ei palauta mitään.
hmm.. tarkoitin siis, että minkä muuttujan tuo return 0 palauttaa, kun en tajua noita kunnolla?
Tommittaja kirjoitti:
hmm.. tarkoitin siis, että minkä muuttujan tuo return 0 palauttaa, kun en tajua noita kunnolla?
Lue kunnolla vastaukset, koska sinulle on sanottu ainakin kaksi kertaa, että return ei palauta muuttujaa vaan arvon. Tässä tapauksessa numeron nolla, joka tarkoittaa operaation onnistunutta suoritusta.
Ei palauta mitään muuttujaa.
return 42; // Palauttaa arvon 42 return 123; // Palauttaa arvon 123 int a = 72; return a; // Palauttaa arvon 72; Palauttaa arvon, joka oli tallennettu muuttujaan a a = 11; return a; // Palauttaa arvon 11; Palauttaa arvon, joka oli tallennettu muuttujaan a
Lisätäänmpä vielä seuraavaa. Josko sen returnin tajuaisi sitä helpompin, mitä useampi tähän sitä neuvoo.
Kokeile nyt ihmeessä Tommittaja itse vaikka tehdä erilaisia metodeita, jotka palauttavat erilaisia arvoja. Tee kaikenlaisia mitä mieleen tulee. Sitten teet pääohjelman, joka tulostaa noiden metodien palauttamia arvoja. Jos olet jo tehnyt noin, niin tee uudelleen. Kokeilemalla ja tekemällä oppii.
Tässä valmista runkoa, veikkaan että ylläoleva teksti ei ole välttämättä tarpeeksi selkeää.
class ReturnTesti {
public static int palautaInt(){
// Tähän sitten koodia. Keksi itse erilaisia tapauksia.
// Tähän viimeisenä return lause. Kokeile erilaisia.
}
public static String palautaString(){
// Ja koodia joka palauttaa merkkijonon.
// Viimeisenä taas siis return merkkijono.
}
public static void main(String args[]){
System.out.println(palautaInt());
System.out.println(palautaString());
// Harjoittellaan myös sijoittamaan palautettu arvo muuttujaan.
int a = palautaInt();
System.out.println(a);
}
}Tee siis erilaisia metodeita, oikeasti. Esim. metodi joka ottaa parametrinä luvun ja palauttaa merkkijonon "suurempi" tai "pienempi" riippuen siitä onko luku suurempi vai pienempi kuin 0 (Vinkkinä if ja 2 erillistä return lausetta). Tee metodit, jotka palauttavat jokaisen tietämäsi tyypin tyyppistä tietoa. Jos herää kysymys, että "Toimisikohan tuo, jos.." niin se selviää kokeilemalla.
Kaiken saamasi ohje- ja opastusmäärän jälkeen pitäisi tuo return nyt pystyä tajuamaan, jos vain olet ajatuksen kanssa lukenut saamasi neuvot.
nyt kyllä tuli semmoinen ongelma vastaan, että huhhuh: mitä tämä tekisi, onko mitään väliä onko monts muuttujaa vai onko turha toinen?
public static int palautas() {
int a = 0;
int b = 0;
return 99;
}ei tuota oikein testaamalla keksi..
Tommittaja kirjoitti:
public static int palautas() { int a = 0; int b = 0; return 99; }ei tuota oikein testaamalla keksi..
Miten olisi vaikka
System.Out.println( palautas() );
Mitä luulet mitä tuo voisi tehdä? Voisiko se tulostaa näytölle luvun 99? Noita kahta muuttujaa ei edes käytetä mihinkään, joten niiden olemassa ololle ei ole mitään tarvetta.
jaa tietenkin.. :D
PS: kiitos tuosta kommentista
Hunajavohveli kirjoitti:
Jos taulukon ensimmäinen indeksi on tarkoitus tulkita vaaka- tai toinen pystykoordinaattina, siirrä j-silmukka ulommaiseksi:
on aina mennyt koordinaatit väärinpäin, ihmettelin siirtymissuuntia asetellessa, että miksi ylös = vasen yms... ;D
Edit: muuten, tässä on 2 tasoa valmiina siitä "labyrinttipelistä" josta puhuin tuolla keskustelun alussa. Koodi voi olla vähän kökköinen, mutta se toimii, ainakin muuten, paitsi että tuo ko. ohjelma ei laske syötyjä hedelmiä?
Tässä itse koodi:
import java.util.Scanner;
public class Labyrinttipeli {
public static Scanner Lue = new Scanner(System.in);
public static void taso1() {
char[][] taulu = {{'#','#','#','#','#','#','#','#','#','#','#'},
{'#',' ','#',' ',' ',' ','#',' ',' ',' ','#'},
{'#',' ','#',' ','#',' ','#',' ','#',' ','#'},
{'#',' ','#',' ','#',' ','#',' ','#',' ','#'},
{'#',' ','#',' ','#',' ','#',' ','#',' ','#'},
{'#',' ','#',' ','#',' ','#',' ','#',' ','#'},
{'#',' ','#',' ','#',' ','#',' ','#',' ','#'},
{'#',' ','#',' ','#',' ','#',' ','#',' ','#'},
{'#',' ',' ',' ','#',' ',' ',' ','#',' ',' '},
{'#','#','#','#','#','#','#','#','#','#','#'}};
char ukko = 'Q';
char liike = ' ';
char tyhja = ' ';
boolean nykyinenkentta = true;
// ukon aloituspaikka
int x = 1;
int y = 1;
taulu[x][y] = ukko;
// piirretään taulukko
while (nykyinenkentta) {
for (int i=0; i<10; ++i) {
for (int j=0; j<11; ++j) {
System.out.print(taulu[i][j]);
if (j == 11-1) System.out.print("\n");
}
}
try {
liike = Lue.next().charAt(0);
} catch (Exception e) {}
// siirrytään
switch(liike) {
case 'w': // ylös
taulu[x][y] = tyhja; // ukko poistetaan
x--;
if (taulu[x][y] == '#' && liike == 'w') {
taulu[x][y] = '#';
x++;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko; // määritellään uusi ukon paikka
break;
case 's': // alas
taulu[x][y] = tyhja;
x++;
if (taulu[x][y] == '#' && liike == 's') {
taulu[x][y] = '#';
x--;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko;
break;
case 'a': // vasen
taulu[x][y] = tyhja;
y--;
if (taulu[x][y] == '#' && liike == 'a') {
taulu[x][y] = '#';
y++;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko;
break;
case 'd': // oikea
taulu[x][y] = tyhja;
y++;
if (taulu[x][y] == '#' && liike == 'd') {
taulu[x][y] = '#';
y--;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko;
break;
default: System.out.println("Virhe ");
break;
}
if (taulu[x][y] == taulu[8][10]) {
System.out.println("voitit ensimmäisen tason!");
break;
}
}
}
public static void taso2() {
char[][] taulu = {{'#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#'},
{'#',' ','#',' ',' ',' ',' ','#',' ',' ','#','#','#',' ',' ',' ','#','#',' ',' ',' ',' ','#'},
{'#',' ','#',' ','#','#',' ','#','#',' ',' ',' ','#',' ','#',' ','#','#',' ','#','#',' ','#'},
{'#',' ',' ',' ','#','#',' ','#','#',' ','#',' ','#',' ','#',' ','#','#',' ',' ','#',' ','#'},
{'#',' ','#','#',' ',' ',' ',' ',' ',' ','#',' ','#',' ','#',' ','#','#','#',' ','#',' ','#'},
{'#',' ','#','#','#','#','#','#','#','#','#',' ','#',' ','#',' ','#','#',' ',' ','#',' ','#'},
{'#',' ',' ','#','#',' ',' ',' ','#','#',' ',' ',' ',' ','#',' ','#','#',' ','#','#',' ','#'},
{'#','#',' ','#',' ',' ',' ',' ',' ','#','#','#','#','#','#',' ','#','#',' ',' ','#',' ','#'},
{'#',' ',' ','#',' ','#','#','#',' ','#',' ',' ',' ',' ',' ',' ','#','#','#',' ','#',' ','#'},
{'#',' ','#','#',' ','#','#','#',' ','#','#','#','#','#','#','#','#','#',' ',' ','#',' ','#'},
{'#',' ',' ','#',' ',' ','#',' ',' ','#',' ',' ',' ','#',' ',' ',' ','#',' ','#','#',' ','#'},
{'#','#',' ','#','#',' ','#','#',' ','#',' ','#',' ',' ',' ','#',' ','#',' ',' ','#',' ','#'},
{'#',' ',' ','#','#',' ','#','#',' ','#',' ','#','#','#','#','#',' ','#','#',' ','#',' ','#'},
{'#',' ','#','#',' ',' ','#',' ',' ','#',' ','#',' ',' ',' ','#',' ','#',' ',' ','#',' ','#'},
{'#',' ',' ','#',' ','#','#',' ','#','#',' ','#',' ','#',' ',' ',' ','#',' ','#','#',' ','#'},
{'#','#',' ','#',' ','#','#',' ','#',' ',' ','#',' ','#','#','#','#','#',' ','#',' ',' ','#'},
{'#',' ',' ','#',' ','#','#',' ','#',' ','#','#',' ','#',' ',' ',' ','#',' ','#',' ','#','#'},
{'#',' ','#','#',' ','#',' ',' ','#',' ','#',' ',' ',' ',' ','#',' ','#',' ','#',' ',' ','#'},
{'#',' ',' ',' ',' ','#',' ',' ',' ',' ','#',' ','#','#','#','#',' ',' ',' ','#','#',' ',' '},
{'#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#'}};
char ukko = 'Q';
char liike = ' ';
char tyhja = ' ';
char hedelma = 'o';
int elkku = 3;
int hedelmat = 0;
boolean nykyinenkentta = true;
// hedelmät
int hedelma1_x = 11;
int hedelma1_y = 8;
taulu[hedelma1_y][hedelma1_x] = hedelma;
int hedelma2_x = 7;
int hedelma2_y = 13;
taulu[hedelma2_y][hedelma2_x] = hedelma;
int hedelma3_x = 19;
int hedelma3_y = 5;
taulu[hedelma3_y][hedelma3_x] = hedelma;
// ukon aloituspaikka
int x = 1;
int y = 1;
taulu[x][y] = ukko;
// piirretään taulukko
while (nykyinenkentta) {
for (int i=0; i<20; ++i) {
for (int j=0; j<23; ++j) {
System.out.print(taulu[i][j]);
if (j == 23-1) System.out.print("\n");
}
}
try {
liike = Lue.next().charAt(0);
} catch (Exception e) {}
// siirrytään
switch(liike) {
case 'w': // ylös
taulu[x][y] = tyhja; // ukko poistetaan
x--;
if (taulu[x][y] == '#' && liike == 'w') {
taulu[x][y] = '#';
x++;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko; // määritellään uusi ukon paikka
break;
case 's': // alas
taulu[x][y] = tyhja;
x++;
if (taulu[x][y] == '#' && liike == 's') {
taulu[x][y] = '#';
x--;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko;
break;
case 'a': // vasen
taulu[x][y] = tyhja;
y--;
if (taulu[x][y] == '#' && liike == 'a') {
taulu[x][y] = '#';
y++;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko;
break;
case 'd': // oikea
taulu[x][y] = tyhja;
y++;
if (taulu[x][y] == '#' && liike == 'd') {
taulu[x][y] = '#';
y--;
taulu[x][y] = ukko;
}
taulu[x][y] = ukko;
break;
case 'L': System.out.println("Lopetit pelin");
nykyinenkentta = false;
default: System.out.println("Virhe ");
break;
}
if (taulu[x][y] == taulu[18][22] && hedelmat == 3) {
System.out.println("Voitit toisen tason!");
break;
}
else if (taulu[x][y] == taulu[18][22] && hedelmat != 3) {
System.out.println("Et ole kerännyt kaikkia hedelmiä");
}
if (taulu[x][y] == 'o') {
hedelmat++;
}
}
}
public static void main(String[] args) {
taso1();
taso2();
}
}Tommittaja kirjoitti:
Koodi voi olla vähän kökköinen, mutta se toimii, ainakin muuten, paitsi että tuo ko. ohjelma ei laske syötyjä hedelmiä?
Koska tyhjennät ruudun siirtämisen yhteydessä, ja tarkistat hedelmän vasta ihan viimeisenä. Tarkista se ennen kuin tyhjennät ruudun johon siirretään.
Hmm.. ei toimikkaan, annatkos esimerkin?
case 'd': // oikea
taulu[x][y] = tyhja;
y++;
if (taulu[x][y] == '#' && liike == 'd') {
taulu[x][y] = '#';
y--;
taulu[x][y] = ukko;
}
if (taulu[x][y] == 'o') {
hedelmat++;
}
taulu[x][y] = ukko;
break;jaa noin, kiitos..
Edit: nyt toimii!!!
Aihe on jo aika vanha, joten et voi enää vastata siihen.