Disposizione random

[stellacometa]

Salve ragazzi allooora..Sono in un vicolo cieco...

Sto programmando un giochetto con pascal.. un'opzione del gioco richiede di far disporre le pedine ('O') nella griglia di gioco(una matrice 7x7) in modo random. Io ho fatto così ma non mi stampa nulla..

program dispos;
type matrice = array [1..7, 1..7] of char;

var
cont, ped, i, j,y: integer;
mat: matrice;

writeln ('Inserisci il numero di pedine');
readln (ped);
cont:=1;

while (cont<=ped) do
begin
for i:=1 to 7 do
for j:=1 to 7 do
begin
y:=0;
randomize;
y:= random (2);
end;

if y=1 then
mat [i,j]:= 'O';
cont:=cont+1;
end;

La variabile cont mi serve per utilizzare solo il numero di pedine che ho deciso di utilizzare..HELP

[stellacometa]

Io l'ho sempre detto che ti devo fare una statua a te...

Cmq il mio quesito iniziale era: apro il gioco, scelgo come voglio disporre le pedine..e poi voglio sapere se posso muovere oppure sono gia in stallo... Il tuo controllo sulla direzione della mangiata mi sfuggiva..lo inseriro con il resto delle direzioni...però il problema in qui sbatto da giorni la testa e se posso sapere subito se sono o meno in stallo non appena dispongo le pedine sulla griglia...

[lorven]

"Sergio":Scusa, ma c'è una cosa che non capisco.
Le pedine si possono muovere solo mangiando?

Sì. C'è situazione di stallo, e quindi si è perso, quando c'è sulla griglia più di una pedina e non è più possibile mangiare.

[lorven]

"stellacometa2003":...
Cmq il mio quesito iniziale era: apro il gioco, scelgo come voglio disporre le pedine..e poi voglio sapere se posso muovere oppure sono gia in stallo... Il tuo controllo sulla direzione della mangiata mi sfuggiva..lo inseriro con il resto delle direzioni...però il problema in qui sbatto da giorni la testa e se posso sapere subito se sono o meno in stallo non appena dispongo le pedine sulla griglia...

Basta attivare la funzione che calcola il numero di mosse valide al momento opportuno.

[lorven]

"Sergio":[quote="lorven"]Sì. C'è situazione di stallo, e quindi si è perso, quando c'è sulla griglia più di una pedina e non è più possibile mangiare.

Be', mi pare una regola un po' crudele [/quote]
E' vero, ma il gioco (di cui ancora non ricordo il nome ) è fatto così!
...

"Sergio":Se d'accordo, posto il codice.

Era già pronto da ieri, ma preferivo "indirizzare" stellacometa2003 alla corretta soluzione

[lorven]

"Sergio":[quote="lorven"]Era già pronto da ieri,

Non ne dubito

ma preferivo "indirizzare" stellacometa2003 alla corretta soluzione

Ok.[/quote]
E' senz'altro gradito qualunque apporto utile a stellacometa2003

[stellacometa]

WOW...Ragazzi così mi fate emozionare per questa vostra disponibilità ... Vi ringrazio!! Comunque come ben dice lorven, mi ci voglio scervellare ancora un pò Se non riesco posto...Grazie di tutto

[stellacometa]

Allora..innanzi tutto per controllare le mosse che può fare una singola pedina dopo che la seleziono:

 if ((mat[i+1, j] <> 'o') and (mat[i-1, j] <> 'o')) then
                if ((mat[i,j+1] <> 'o') and (mat[i,j-1]<>'o')) then
                   writeln ('Nessuna mossa disponibile con questa padina'); 
                     readln

Era scontato insomma visto che il pulpito proviene da lorven ...Ora passo all'altro "problemino"...

[stellacometa]

Wooow forse ci sono

 for i:=1 to 7 do
  for j:=1 to 7 do
    begin
      if mat[i,j]='o' then
      begin
       if ((mat[i+1, j] <> 'o') and (mat[i-1, j] <> 'o')) then
        if ((mat[i,j+1] <> 'o') and (mat[i,j-1]<>'o')) then
         Dec (ped);
          if ped=0 then
          begin
          Writeln ('stallo');
          readln ;
          Exit;
  end
  end
  end

Vado forte eh??????????

Correzioni e accorgimenti di errori accettati...

[lorven]

"Sergio":Dato che è solo un frammento del codice potrei interpretare male

Inviterei stellacometa2003 ad almeno abbozzare un main che attiva tutto il resto, altrimenti è difficile dare suggerimenti;

"Sergio": comunque mi pare ci siano due problemi:
a) ancora non vedo il controllo sui bordi della scacchiera; se la scacchiera è il solito array [1..7,1..7], allora se la pedina in mat[i,j] è, ad esempio, nella posizione [1,7], quando provi a vedere cosa c'è in mat[i-1,j] o in mat[i,j+1], cioè in mat[0,7] o in mat[1,8], vai oltre i limiti dell'array;

Si potrebbe rimediare, come diceva prima Sergio, anche aggiungendo una "cornice" alla matrice;

b) se non ho capito male le regole, la casella in cui una pedina salta quando ne mangia un'altra deve esistere e deve essere vuota; ad esempio, una pedina in mat[2,6] non può mangiarne un'altra in mat[2,7] perché dovrebbe saltare in mat[2,8] che non c'è; oppure, se ci sono tre pedine in mat[3,4], mat[3,5] e mat[3,6], nel tuo codice possono mangiare tutte e tre mentre - sempre se ho capito bene le regole, solo quella di mezzo può mangiare una delle altre due.

Dovrebbe essere questa la regola del gioco, ammesso che io, a mia volta, l'abbia capita!
La verifica della situazione di stallo, su cui -pare- stellacometa2003 sia in stallo , potrebbe essere risolta come nello spoiler:

function NumMosseValide(m: Matrice): integer;
var mosse, i, j:integer;
begin
mosse := 0;
writeln('mosse possibili:');
for i := 1 to r do
    for j := 1 to c do
        begin
        if m[i,j] = car then
            begin
            // Devi assicurarti che gli indici i e j siano nell'intervallo corretto
            if (i < r-1) then if ((m[i+1, j] = car) and (m[i+2, j] <> car)) then
                begin writeln(i,j,'->',i+2,j);inc(mosse);end; // S
            if (j < c-1) then if ((m[i, j+1] = car) and (m[i, j+2] <> car)) then
                begin writeln(i,j,'->',i,j+2);inc(mosse);end; // O
            if (i > 2) then if ((m[i-1, j] = car) and (m[i-2, j] <> car)) then
                begin writeln(i,j,'->',i-2,j);inc(mosse);end; // N
            if (j > 2) then if ((m[i, j-1] = car) and (m[i, j-2] <> car)) then
                begin writeln(i,j,'->',i,j-2);inc(mosse);end; // E
            end;
        end;
NumMosseValide := mosse;
end; 

Come dicevo prima, è una verifica da effettuare al momento opportuno, ossia prima di ciascuna mossa!

[stellacometa]

Non so come ringraziarvi prima per la vostra disponibilità...ho mandato in esecuzione il codice di lorven è funziona perfettamente...però non mi va l'idea di scopiazzare codici senza capirne il ragionamento o almeno aver provato a mettere su una mia bozza... Quindi la prima cosa che mi viene da domandare a lorven è qual'è stato il ragionamento che ha messo in atto per avere pure le mosse disponibili...

[lorven]

"stellacometa2003":Non so come ringraziarvi prima per la vostra disponibilità...ho mandato in esecuzione il codice di lorven è funziona perfettamente...però non mi va l'idea di scopiazzare codici senza capirne il ragionamento o almeno aver provato a mettere su una mia bozza... Quindi la prima cosa che mi viene da domandare a lorven è qual'è stato il ragionamento che ha messo in atto per avere pure le mosse disponibili...

Semplicemente, per ogni cella occupata, si verifica se nelle celle immediatamente adiacenti c'è una pedina, controllando altresì che la cella successiva (nella stessa direzione della cella adiacente in questione) sia libera, onde consentire alla pedina che mangia il posizionamento corretto.
Naturalmente, le verifiche (sulle celle adiacenti e sulle immediatamente successive nella stessa direzione della "mangiata") sono suborbinate al controllo che quelle celle esistano, che gli indici delle celle siano cioè nell'ambito delle dimensioni della matrice. (Più difficile a dirsi che a farsi )

[vict85]

"stellacometa2003":Allora...questo gioco somiglia alla dama...

Si parte da una disposizione iniziale delle pedine. Lo scopo del gioco è quello di eliminare via via le pedine mediante delle mosse che consistono nel far saltare una pedina oltre una di quelle adiacenti, per posizionarsi così su di una cella vuota. Si può muovera la pedina solo in orizzontale e verticale. La pedina "mangiata" viene ovviamente rimossa dalla griglia di gioco. Si vince quando tutte le pedine vengono mangiate e ne resta solo una.

Questo riguarda le regole in generale, poi gli voglio mettere il punteggio e varie opzioni che pian piano mi vengono le ispirazioni mi propongo di sviluppare anche qui..tipo punteggi migliori, pedine mangiate ecc. Intanto vorrei risolvere il problema appena postato della situazione di stallo... che mi suggerite?

Ma implementi anche l'AI? Considerando il gioco sarebbe un min-Max...

[lorven]

"Sergio":
...Torniamo ora al codice di lorven.
Si considera non solo la cella adiacente in una direzione (che deve contenere "car"), ma anche quella successiva nella stessa direzione (che deve essere libera, quindi non deve contenere "car"). Poi:

if (i < r-1) then if ((m[i+1, j] = car) and (m[i+2, j] <> car)) then

dal momento che si vede cosa c'è in m[i+1, j] ed in m[i+2, j], si verifica che i sia minore di r-1.

if (j < c-1) then if ((m[i, j+1] = car) and (m[i, j+2] <> car)) then

dal momento che si vede cosa c'è in m[i, j+1] ed in m[i, j+2], si verifica che j sia minore di c-1.

if (i > 2) then if ((m[i-1, j] = car) and (m[i-2, j] <> car)) then

dal momento che si vede cosa c'è in m[i-1, j] ed in m[i-2, j], si verifica che i sia maggiore di 2.

if (j > 2) then if ((m[i, j-1] = car) and (m[i, j-2] <> car)) then

dal momento che si vede cosa c'è in m[i, j-1] ed in m[i, j-2], si verifica che j sia maggiore di 2.

Grazie, Sergio, per aver chiarito quello che intendevo con parole meno ermetiche!

[stellacometa]

Grazie a tutti ragazzi per il vostro aiuto...ora mi dedico ai punteggi e come al solito se vado in "stallo" posto qui...GRAZIEE