Olimpo Informatico

[saetta]

Devo realizzare wator in linguaggio c
in breve è un ecosistema che consiste in un area di oceano (matrice rettangolare) dove gli elementi possono essere vuoti, contenere 1 pesce o contenere uno squalo.
pesci e squali hanno alcune regole per mangiare, muoversi,riprodursi e morire. (se volete approfondire basta cercare con google "wator", trovate subito qualcosa.)

voglio realizzare un array di puntatori (ptr) a righe(le quali hanno come elementi 'ptr a struct cell'), e manterrò in un'altra matrice le vere e proprie strutture aggiornando dunque solo i puntatori e nn spostando il tutto.
Ho dichiarato nella funzione che crea un nuovo ambiente:

struct cell *(*r)[row];/* (ptr a)vettore[row] di prt a cell*/
struct cell *(c)[col];/* ptr a vettore[col] di cell*/

r = &c;
con row e col parametri da utente.

credo che sia sbagliato di concetto ma anche scrivere
union cell ptr***;/*vettore di ptr a ptr a cell*/
non mi torna.
insomma non so se tali dichiarazioni rispecchiano quello che volevo fare.

grazie a tutti.

[SverX]

[saetta]

-------------------- specifica----------------

Wa-Tor e' un semplice modello di andamento della popolazione acquatica studiato in ecologia. Questo modello e' diventato popolare dopo esser stato presentato nella colonna Computer Recreations della rivista Scientific American [A. K. Dewdney, Sharks and fish wage an ecological war on the toroidal planet Wator, Scientific American, December 1984]. Wa-tor e' un pianeta ricoperto interamente da un oceano temperato. L'oceano e' abitato da predatori (gli squali) e prede (i pesci). Wator viene rappresentato da una matrice rettangolare. Ogni elemento della matrice rappresenta un'area dell'oceano che puo' essere in tre stati distinti

*
puo' essere vuota
*
puo' contenere esattamente un pesce
*
puo' contenere esattamente uno squalo.

Siccome Wator e' un pianeta rotondo le celle della prima riga (colonna) sono adiacenti alle celle dell'ultima riga (colonna).

Il tempo e' a sua volta suddiviso in unita' standard dette chronons, il sistema si evolve in passi che corrispondono ad un chronon ciascuno. Ad ogni passo la matrice che rappresenta il pianeta viene aggiornata secondo le seguenti regole:

*
Gli squali mangiano e si spostano. A ogni passo, uno squalo presente in una cella (i,j) si guarda intorno nelle celle adiacenti. Se una di queste celle contiene un pesce, lo squalo mangia il pesce e si sposta nella cella precedentemente occupata dal pesce. Se nessuna delle celle adiacenti contiene un pesce, lo squalo si sposta in una delle celle adiacenti vuote. Le celle adiacenti sono le celle in cui uno degli indici differisce esattamente di uno da i e j. Cioe' (i-1,j), (i,j-1),(i,j+1), (i+1,j). Graficamente

..............(i-1,j)...............
.....(i,j-1) (i,j+1).....
..............(i+1,j)..............

*
Gli squali si riproducono e muoiono Se uno squalo sopravvive per almeno Sb chronon si riproduce: se e' disponibile una cella adiacente vuota questa viene occupata da un nuovo squalo. Lo squalo che si e' appena riprodotto potra' farlo di nuovo dopo altri Sb chronon. D'altra parte, se uno squalo no mangia per Sd chronon muore e scompare dalla griglia.

*
I pesci si spostano A ogni passo un pesce si sposta casualmente in una delle celle adiacenti. Siccome Wator e' un pianeta rotondo i pesci (e gli squali) possono nuotare verso l'esterno di un lato della matrice e risbucare dal lato opposto.

*
I pesci si riproducono Se un pesce sopravvive per almeno Fb chronon si riproduce: se e' disponibile una cella adiacente vuota questa viene occupata da un nuovo pesce. Il pesce che si e' appena riprodotto potra' farlo di nuovo dopo altri Fb chronon.

All' inizio della simulazione, la griglia deve essere riempita casualmente con NS squali e NF pesci. Ogni squalo (pesce) e' munito di un contatore, inizializzato a zero ed incrementato ad ogni chronon. Quando il valore del contatore raggiunge Sb (Fb) lo squalo (il pesce) si riproduce ed il contatore viene di nuovo azzerato.

Ogni volta che un pesce o uno squalo puo' scegliere di muoversi, mangiare, riprodursi, deve farlo scegliendo in maniera casuale fra le possibile alternative.

Questo modello, per quanto semplice, e' sufficiente a fornire un comportamento simile a quello che viene osservato davvero in alcune popolazioni in natura. Se c'e' abbastanza pesce, gli squali prosperano e si riproducono finche' non raggiungono un numero troppo elevato. a questo punto quasi tutto il pesce verra' divorato e iniziera' un periodo di carestia.

Si chiede di realizzare un programma C che implementi il comando wator che simula il comportamento del pianeta visualizzandone lo stato ad ogni chronon/ I parametri Sd, Sb, Fb, NF, NS ed il numero di righe e colonne della matrice devono essere specificabili da linea di comando.

Si consiglia di utilizzare una matrice separata per raccogliere gli aggiornamenti e di calcolare prima gli aggiornamenti relativi agli squali. Inoltre e' preferibile rappresentare ogni matrice come array di puntatori a righe. Per la visualizzazione e' possibile usare sleep() e usleep() per attendere fra una visualizzazione e la successiva e system(?clear?) per pulire lo schermo.
----------------------fine specifica----------------------------------------

---------------------------------------
questo è il mio file.h:
---------------------------------------


# include <stdio.h>
# include <stdlib.h>


/*shark*/

typedef struct
{
int utype;
int sb;
int sd;
int pos[2];
} shark;


/*fish*/

typedef struct
{
int utype;
int fb;
int pos[2];
}fish;


/*empty*/

typedef struct
{
int utype;
}empty;



/*wator's inhabitants: a fish, or a shark*/
typedef union
{
struct shark *sh;
struct fish *fi;
}inha;



/*content of a wator's cell: a fish, a shark or nothing*/
typedef union
{
struct empty *em;/*ptr ad una cella vuota*/
union inha *inh;/* o un ptr a un abitante*/


}cell;

/*FUNZIONI*/

/* newator(): creazione ambiente wator
prende i param per la creazione e restituisce
un puntatore ad array(dim=c) di righe(di dim r) di struct cell*/
union cell **newator(int r, int c, int nf, int ns, int fb, int sb, int sd);

--------------------------------------------
QUESTO È IL MIO FILE .c
--------------------------------------------
# include "wator.h"

enum utype {SH = 2, FI = 1, EM = 0};

union cell **newator(int row, int col, int nf, int ns, int fb, int sb, int sd)
{
int i;
int ncell = (col*row);

union cell *(*r)[row];/* ptr a vettore[row] di prt a cell*/
/*struct cell *(c)[col]; ptr a vettore[col] di cell*/

/*r = &c;r punta alla pos di c (il quale punta a c[0])*/


for (i=0; i<ncell; i++)
{
if((r = (union cell**) calloc(ncell,sizeof(cell)))== NULL)
{
do
{
printf("Errore allocazione memoria;");
newator(row, col, nf, ns, fb, sb, sd);
}
while((i=3));

}/*if*/
}

}
----------------------------------------------

Sto cercando di implementare la newator() che mi dovrebbe preparare l'ambiente rappresentativo del sistema wator.
Come vedi mi sono creata una gerarchia di tipi:


union cell::= struct empty | union inha
union inha::=struct shark | struct fish

Non so se è una buona idea e ho usato anche il tipo empty per rendere omogenea la cosa (forse solo nel mio cervello)
Inoltre ancora non so se "int pos[2]", per mantenere la posizione dentro alla descrizione di ogni singolo fish o shark è superflua,

Le matrici che vorrei creare sono due:
--M per contenere effettivamente i fish, gli shark o gli empty con le loro caratteristiche individuali
--N per mantenere i collegamenti con gli elementi in N e in caso di spostamenti cavarmela solo assegnando il nuovo valore ai puntatori in N

Insomma... credo che ci siano delle belle cacchiate di concetto nel codice... anche se compila con un solo warning...(assegnamento a tipo incompatibile alla calloc nel file.c)

Grazie per la pazienza.

[SverX]

guarda... a mio avviso il problema si potrebbe affrontare partendo da due punti diversi:

1. una matrice di NxM elementi nel quale ogni elemento è composto da un numero (un enum 0,1,2) e da un puntatore. Il numero rappresenta 'cosa' c'è dentro quell'elemento della matrice (ad es. 0 = niente, 1 = pesce, 2 = squalo ) e il puntatore punta all'elemento 'pesce' o all'elemento 'squalo'.

2. due liste, una di pesci e una di squali. In ogni lista ogni elemento contiene i dati del pesce/dello squalo e la sua posizione. Ovviamente cercare le celle vuote (o piene) adiacenti diventa un lavoro più complicato (dovrai scorrere entrambe le liste tutte le volte) ma c'è il vantaggio che non devi costruire davvero nessuna matrice...

non è detto che non ci siano altre possibilità... comunque -purtroppo- io non ho ancora capito la tua idea. E prima di scrivere codice è meglio avere ben chiaro in testa cosa fare, altrimenti si butta via davvero tanto tempo...

[saetta]

in effetti mi faccio prendere dalla fretta di cominciare a buttare giù il codice...soprattutto perchè contemporaneamente lavoro e sto realizzando altri 2 progetti più grossi (di cui uno in java) e volevo "sbrigarmi" a fare questi esercizi più semplici per imparare tutto il necessario...velocemente...
Ma così non risolvo nulla!

Ti ringrazio per la disponibilità, proverò a fare come proponi nella prima soluzione, che poi era la mia idea iniziale...ma ci ho aggiunto una marea di cavolate.
a presto!!!

Saetta