Perplessità processi (c,java,python, generico)

« Older   Newer »
  Share  
view post Posted on 21/2/2020, 16:39
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


vediamo :)
nota: getch() è fastidiosa per i giochi, infatti si usano spesso alternative (ricordiamo la mitica ... WAIT 197,64,64 del C64? ! :) )
Ci dovrebbe essere qualche chiamata del BIOS non bloccante, ricordo qualcosa dei pochi giochini che scrissi in DOS (e spero anche in linux/unix)
 
Top
view post Posted on 21/2/2020, 16:45
Avatar

Rompiball

Group:
Appassionati
Posts:
2,612
Location:
briansa

Status:


Ah, non lo sapevo...proverò a spulciare il web
Bhe, comunque con una pipe non bloccante sembra andare bene.
Adesso ci sono d'aggiungere altre cose...eh...con calma.
Spero di chiudermi la strada. Ho il sospetto che andrebbe strutturato diversamente, ma più faccio più capisco
dove correggere. A teoria funziona sempre tutto
 
Top
view post Posted on 21/2/2020, 17:32
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


:)
dal video mi sembra ok...
 
Top
view post Posted on 21/2/2020, 17:39
Avatar

Rompiball

Group:
Appassionati
Posts:
2,612
Location:
briansa

Status:


Si, ci sono cose migliorabili sicuramente, ma voglio provare a finire, poi al massimo ritocco.
Sarebbe bello capire come va impostato quale processo deve fare cosa ecc...
 
Top
view post Posted on 21/2/2020, 18:06
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


Io anni fa avevo scritto "ARROWS", che era un vecchissimo gioco da sala giochi (tipo 1979) dove avevi il bruco e dovevi andare a prendere (centrare) dei piccoli banner con i punti, senza mai "morderti" e scansando degli "ostacoli" che ti davano PENalità (nel senso che ti cresceva il bruco :D :D )

Posso postare il codice - è molto banale perché l'avevo scritto per una scheda Z80, la mia primissima domotica del 1992! però compilava e girava pure in DOS

eccolo. notare il "if(kbhit())" prima di getch() :D

CODICE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <conio.h>
#include <io.h>
#include <fcntl.h>
#include <time.h>
#ifndef Z80
#include <dos.h>
#endif

#ifndef Z80
#define INT_VID 0x10
#define VID_SCUP 0x06
#define VID_SCDN 0x07
#define VID_SETP 0x05
#define VID_SETC 0x02
#define V_DISP 0x07
#define SCR_W 80
#define SCR_H 25
#define UP_CHR '^'
#define DN_CHR 'V'
#define LF_CHR '<'
#define RG_CHR '>'
#define BOX_H (SCR_H / 8)
#define BOX_W (SCR_W / 8)
#define BOX_TIME 4000
#define SEC_TIME 1000
#define MOVE_TIME 250
#else
#define SCR_W 40
#define SCR_H 4
#define BOX_H 1
#define BOX_W 5
#define UP_CHR '^'
#define DN_CHR 'V'
#define LF_CHR '<'
#define RG_CHR '>'
#define BOX_TIME 80
#define MOVE_TIME 10
#define SEC_TIME 25
#endif


char xPos,yPos;
char Dir,mChr;
char lPosX[20],lPosY[20];
char lLen;
char Bx,By,Bp,Bok;

#ifndef Z80
#define home() cursor(1,1)

void cursOn() {
       union REGS ir;

       ir.h.ah=1;
       ir.h.ch=2;
       ir.h.cl=7;
       int86(INT_VID,&ir,&ir);
       }

void cursOff() {
       union REGS ir;

       ir.h.ah=1;
       ir.h.ch=8;
       ir.h.cl=0;
       int86(INT_VID,&ir,&ir);
       }

int BlankSc(int tlrow,int tlcol,int brrow,int brcol) {
       union REGS ir;
       
       if (tlrow < 1) tlrow = 1;
       if (tlrow > SCR_H) tlrow==SCR_H;
       if (tlcol < 1) tlcol = 1;
       if (tlcol > SCR_W) tlcol = SCR_W;
       if (brrow < 1) brrow = 1;
       if (brrow > SCR_H) brrow = SCR_H;
       if (brcol < 1) brcol = 1;
       if (brcol > SCR_W) brcol = SCR_W;

       ir.h.ah = VID_SCUP;
       ir.h.al = 0;
       ir.h.ch = tlrow -1;
       ir.h.cl = tlcol -1;
       ir.h.dh = brrow -1;
       ir.h.dl = brcol -1;
       ir.h.bh = V_DISP;

       int86(INT_VID, &ir, &ir);

       }

cls()
{
       BlankSc(1,1,SCR_H,SCR_W);
       home();
       }

cursor(char col, char row) {
       union REGS ir;

       if (row < 1) row = 1;
       if (row > SCR_H) row = SCR_H;
       if (col < 1) col = 1;
       if (col > SCR_W) col=SCR_W;

       ir.h.ah = VID_SETC;
       ir.h.bh = 0;
       ir.h.dh = row -1;
       ir.h.dl = col -1;

       int86(INT_VID, &ir, &ir);

 }

#endif  
 
PtBox(char m, char x, char y, unsigned char v) {
 char i,j,k;
 
 if(x >= SCR_W-BOX_W)
   x=SCR_W-BOX_W-1;
 if(y >= SCR_H-BOX_H)
   y=SCR_H-BOX_H-1;
 if(m) {
         k=BOX_H >> 1;
//          if(k == 0)
//            k=1;  
         for(i=0; i<BOX_H; i++) {
           for(j=0; j<BOX_W; j++) {
             cursor(j+x,i+y);
             putch('*');
             }
           }  
         cursor(x+(BOX_W/2-1),y+k);
         v %= 10;
         if(v) {
           printf("%1d00",v);
           Bp=v;
           }
         else  {
           printf("???");
           Bp=(rand() % 19)-9;
           if(!Bp)
             Bp++;
           }
         }
       else {
         for(i=0; i<BOX_H; i++) {
           for(j=0; j<BOX_W; j++) {
             cursor(j+x,i+y);
             putch(' ');
             }
           }  
         }    
 }
 
center(char *s) {
 register unsigned char i;
 
 i=SCR_W-strlen(s);
 i >>= 1;
 while(i--)
   putch(' ');
 puts(s);
 }
 
main() {
 char i,Exit,ch,mLen,Tim;
 int MoveTime;
 int Punti;
 clock_t t,t1,t2;
 char x,y;

 cursOff();
rifo:
 for(i=0; i<SCR_H; i++)
   putch('\n');
 center("ARROWS");
 center("(C) G.Dar 1994");
 t=clock()+(SEC_TIME*5);
 while(t >= clock()) {
         if(kbhit()) {
           if(getch() == '\x1b') {
                               cursOn();
             exit(4);
             }
           else  
             goto start;
           }  
   }
 goto rifo;  

start:
 Tim=90;
 Punti=0;
 Exit=0;
 lLen=4;
 srand(0);
start2:
 MoveTime=MOVE_TIME;
 Bx=By=0;
 cls();
 mLen=0;
 xPos=SCR_W/2;
 yPos=SCR_H/2;
 Dir=6;
 mChr=RG_CHR;
 t=t2=clock();
 t1=clock()+BOX_TIME;
 t2=clock()+SEC_TIME;
       while(!Exit && Tim) {
               if(kbhit()) {
                 ch=getch();
                 switch(ch) {
                   case '\x1b':
                     Exit=1;
                     break;
                   case '2':
                     Dir=2;
                     mChr=DN_CHR;
                     break;
                   case '4':
                     Dir=4;
                     mChr=LF_CHR;
                     break;
                   case '6':
                     Dir=6;
                     mChr=RG_CHR;
                     break;
                   case '8':
                     Dir=8;
                     mChr=UP_CHR;
                     break;
                     
                   }
                 }
               if(clock() >= t) {
                       lPosX[mLen]=xPos;  
                       lPosY[mLen]=yPos;  
                       cursor(xPos,yPos);
                       putch(mChr);
                 t=clock()+MoveTime;
                 switch(Dir) {
                   case 2:
                     if(yPos<(SCR_H-1))
                       yPos++;
                     break;
                   case 4:
                     if(xPos>0)
                       xPos--;
                     break;
                   case 6:
                     if(xPos<(SCR_W-1))
                       xPos++;
                     break;
                   case 8:
                     if(yPos>0)
                       yPos--;
                     break;
                   }
                       for(i=0; i<lLen; i++) {
                         if(lPosX[i]==xPos && lPosY[i]==yPos) {
error:                          
                           putch(7);
                           if(lLen < 20)
                             lLen+=2;
                           goto start2;  
                           }
                         }
                 if(xPos>=SCR_W || yPos>=SCR_H || xPos<0 || yPos<0) {   // ERRORE negli OR
                   goto error;
                   }
                       if(Bok) {
                         if(xPos>=Bx && yPos>=By && xPos<(Bx+BOX_W) && yPos<(By+BOX_H)) {
                           putch(7);
                           putch(7);
                                 PtBox(0,Bx,By,0);
                                 Bok=Bx=By=0;
                                 Punti+=Bp;
                                 }
                         }
                       
                       if(mLen<lLen)
                         mLen++;
                       else {  
                               cursor(lPosX[0],lPosY[0]);
                               putch(' ');
/*                                for(i=1; i<=lLen; i++) {
                                 lPosX[i-1]=lPosX[i];
                                 lPosY[i-1]=lPosY[i];
                                 }*/
                               memmove(lPosX,lPosX+1,lLen);  
                               memmove(lPosY,lPosY+1,lLen);  
                               }  
                 }  
               if(clock() >= t1) {
                 i=(rand() & 3) +1;
                 t1=clock() + (i*(BOX_TIME/3));
                 if(Bok)
                         PtBox(0,Bx,By,0);
                 x=rand() % SCR_W;
                 y=rand() % SCR_H;
                 PtBox(1,x,y,rand());
                 Bx=x;
                 By=y;
                 Bok=1;
                 }
               if(clock() >= t2) {
#ifndef Z80                
                 MoveTime-=2;
#else
     if(!(Tim & 7))
                   MoveTime--;
#endif                  
                 t2=clock()+SEC_TIME;
                 Tim--;
                 cursor(SCR_W/2-5,0);
                 printf("%2d - %3d00",Tim,Punti);
                 }
         }
 cls();
 cursor(SCR_W/2-5,0);
 printf("%2d - %3d00",Tim,Punti);
 cursor(0,SCR_H-1);
 center("GAME OVER");
 t=clock()+(SEC_TIME*3);
 while(t>=clock());
       goto rifo;  
 }
 
Top
view post Posted on 21/2/2020, 18:34
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


Notare anche i 3 diversi "if clock() > " che erano la mia macchina a stati di quando ignoravo!!
 
Top
view post Posted on 21/2/2020, 18:55
Avatar

Rompiball

Group:
Appassionati
Posts:
2,612
Location:
briansa

Status:


Ora non riesco, poi guardo.
Se ti posto il mio listato fin'ora, hai voglia di guardare?..e' commentato, magari mi dai dritte sulla logica.
Dimmi tu
 
Top
view post Posted on 21/2/2020, 19:12
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


sì certo!
 
Top
view post Posted on 21/2/2020, 19:58
Avatar

Rompiball

Group:
Appassionati
Posts:
2,612
Location:
briansa

Status:


Ecco, quando e se hai voglia...son ben accette critiche (anche pesanti :) ) e consigli

CODICE
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>
#include <ncurses.h>
#include <fcntl.h>
#define ROW 24
#define COL 80
#define WRITE 1
#define READ 0

#define DX 261
#define SX 260
#define DOWN 258
#define UP 259
//*****************************************
// uso 2 array per le direzioni in modo da risparmiare 4 if
int dir_up_down[4]={0,0,-1,1}; // array per direzioni (variabili globali)
int dir_lat[4]={1,-1,0,0};



// prototipi
void prova_pipe_g(int pipe_out,int pipe2);
void prova_pipe_r(int pipe_in);
void tasti (int pipe2);
//****************************************************************************


//****************************************************************************
// routine per gestione tasti: impedisce movimenti in retro
// 261 sarebbe un offset 261-tasto es 258 (261-258)=3
// vuol dire che mando 3 con la pipe che in array int dir_up_down[4]={0,0,-1,1};
// corrisponde ad giu
void tasti (int pipe2)
{
       int ch=0;
       int buff[1];
       int tmp_dir=0;
       while (1)
       {
               ch=getch();

               if (ch==DX && tmp_dir!=1) //se vai a dx,negato sx
               {  
                       buff[0]=261-ch;tmp_dir=buff[0];
                       write(pipe2, buff, sizeof(int));
               }
                       
               if (ch==SX && tmp_dir!=0)
               {        
                       buff[0]=261-ch;tmp_dir=buff[0];
                       write(pipe2, buff, sizeof(int));//scrivo
               }
                       
               if (ch==UP && tmp_dir!=3)
               {  
                       buff[0]=261-ch;tmp_dir=buff[0];
                       write(pipe2, buff, sizeof(int));//scrivo
               }
                       
               if (ch==DOWN && tmp_dir!=2)
               {  
                       buff[0]=261-ch;tmp_dir=buff[0];
                       write(pipe2, buff, sizeof(int));//scrivo
               }
       }
}
               
       
//****************************************************************************
// processo che inizializza il bruco e gestisce i movimenti
// il bruco parte da dx a sx, se riceve una direzione valida
// la direzione cambia
// per muovere il bruco scalo le posizioni dell'array, poi aggiorno la testa
//****************************************************************************


void prova_pipe_g(int pipe_out,int pipe2) //guardia
{
       
       struct
       {
               int x[100];
               int y[100];
               int rnd;
               int tmp_coda_x;
               int tmp_coda_y;
               int corpo;
       }snake;
       snake.corpo=20;
       
       int j,buff[1],x,tmp_x,tmp_y;

       for (j=0; j<snake.corpo-1; j++)
       {
               snake.x[j]=10;  // creo array bruco
                snake.y[j]=31-j;
       }        

       
       for (j=0; j<snake.corpo-1; j++) // stampo bruco
       {
               move(snake.x[j], snake.y[j]);
               addch('@');
       }
       move(snake.x[0], snake.y[0]);
       addch('X');
       refresh();
       
       while(1)
       {
               x=fcntl(pipe2, F_SETFL, O_NDELAY); // attivo flag pipe non bloccante
               if (x!=-1) // se buffer non vuoto--->leggi
                       read(pipe2,buff,1*sizeof(int));
               
               snake.tmp_coda_x=snake.x[snake.corpo-1]; // memorizzo la coda che il padre metterà come spazio
               snake.tmp_coda_y=snake.y[snake.corpo-1];
                               
               for (j=0; j<snake.corpo-1; j++)
               {
                       tmp_x=snake.x[j+1];      // scalo posizioni per muovere
                       tmp_y=snake.y[j+1];      
                       snake.x[j+1]=snake.x[0];
                       snake.y[j+1]=snake.y[0];
                       snake.x[0]=tmp_x;
                       snake.y[0]=tmp_y;
               }

               snake.x[0]=snake.x[1]+dir_up_down[buff[0]]; //aggiorno dir testa in base al tasto arrivato
               snake.y[0]=snake.y[1]+dir_lat[buff[0]];
               write(pipe_out, &snake, sizeof(snake)); // scrivo  al padre
               usleep(90000);
       }
}
               
       

//****************************************************************************
// il padre legge e stampa i dati
//****************************************************************************

void prova_pipe_r(int pipe_in) // pipe padre(legge)
{

       struct
       {
               int x[100];
               int y[100];
               int rnd;
               int tmp_coda_x;
               int tmp_coda_y;
               int corpo;
       }st_padre;
       
       int i;

       
       while(1)
       {
               read(pipe_in,&st_padre,sizeof(st_padre));        // Leggo l'evento
               move (st_padre.tmp_coda_x, st_padre.tmp_coda_y);
               addch(' ');
                       
               for (i=0; i<st_padre.corpo-1; i++)
               {
                       move (st_padre.x[i], st_padre.y[i]);
                       addch('@');
               }
                       
               move (st_padre.x[0], st_padre.y[0]);
               addch('X');refresh();        
                       
       }
}
       

int main(void)
{
       
       int pid[2];
       int my_pipe[2];
       int my_pipe_2[2];
       initscr();   // init ncurses
       cbreak();
       noecho();
       curs_set(0);
       intrflush(stdscr, FALSE);
       keypad(stdscr, TRUE);
       
       
       if (pipe(my_pipe)==-1)
       {
               puts("erroer");
               return -1;
       }

       if (pipe(my_pipe_2)==-1)
       {
               puts("erroer");
               return -1;
       }
       
//********************************************
//                        figlio 1
//********************************************
       
       pid[0] = fork();
       if ( pid[0] == -1 )
       {
               printf ("Impossibile creare un nuovo processo\n");
               exit(1);
       }

       if ( pid[0] == 0 )
       {
               close (my_pipe[READ]);
               prova_pipe_g(my_pipe[WRITE],my_pipe_2[READ]); //passo descrittore pipe scrittura
       }    
       
//********************************************
//                        figlio 2
//********************************************
       
       pid[1] = fork();
       if ( pid[1] == -1 )
       {
               printf ("Impossibile creare un nuovo processo\n");
               exit(1);
       }

       if ( pid[1] == 0 )
       {
               tasti(my_pipe_2[WRITE]); //passo descrittore pipe scrittura
       }    


       else // entro nel padre (main)
       {
               prova_pipe_r(my_pipe[READ]);
       }

       endwin();
       return 0;

}
 
Top
view post Posted on 21/2/2020, 20:37
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


Di nuovo, direi più o meno tutto ok.

Per la getch() bloccante, vedi il mio listato sopra :)

Per quel ritardo di 90000 ... l'idea è, se non la FSM, di fare come ho fatto io: ossia usi clock() o time() ed esegui il movimento solo quando è passato un tot di tempo, altrimenti leggi soltanto la pipe
 
Top
view post Posted on 21/2/2020, 20:51
Avatar

Rompiball

Group:
Appassionati
Posts:
2,612
Location:
briansa

Status:


Clock e time...sono onesto non le so usare, mi documento. Appena riesco guardo il tuo codice, sperando di capirci.
Non sono così bravo e i codici altrui anche se fatti bene faccio fatica a capirli.
Che ne pensi delle "bussole" per le direzioni ?
CODICE
int dir_up_down[4]={0,0,-1,1}; // array per direzioni (variabili globali)
int dir_lat[4]={1,-1,0,0};


Magari inutili, ma così facendo risparmio degli if...che non mi piacciono mai tanto.
Grazie per avergli dato un'occhio ;)
 
Top
view post Posted on 21/2/2020, 20:56
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


Sì, direi che vanno bene e sono un'alternativa alle if :)
Io forse in questo caso avrei usato le IF, perché magari può capitare di voler gestire anche un accelerazione, o un suono diverso... in base alla direzione, e così...
 
Top
view post Posted on 22/2/2020, 09:42
Avatar

Rompiball

Group:
Appassionati
Posts:
2,612
Location:
briansa

Status:


Comunque la funzione
CODICE
nodelay (stdscr, true);

per ncurses rende getch() non bloccante: se nulla premuto da -1. Ottimo direi!!!
Posso eliminare tutta quella parte della pipe non bloccante direi. Non lo sapevo, ncurses
è immensa il tempo è quello che è e a volte la pigrizia di spulciare i manuali si fa sentire,
tanto più che sono in inglese.

@Law: io sto proseguendo, ma sono sempre pronto a sentire cosa mi dici dell'ultima mia risposta.
Come vedi anche questo 3d è un processo: 2 discorsi concorrenti :D :D

muahhh il Gila calcola tutto !!!! :lol: :lol:
 
Top
view post Posted on 22/2/2020, 11:10
Avatar

Noioso

Group:
Professionisti
Posts:
403

Status:


:D

ok allora, sì, immagino che ti risolva il problema in altri termini :)

Oppure, allora, si potrebbe lanciare un processo che fa getch() e ritorna il tasto quando c'è :)
 
Top
view post Posted on 22/2/2020, 21:35
Avatar

Rompiball

Group:
Appassionati
Posts:
2,612
Location:
briansa

Status:


Premetto che con la nuova funzione trovata di ncurses della getch() non bloccante, forse il discorso di fare tutto a processi
viene meno. Io temevo appunto che getch() per la ricezione tasti mi bloccasse tutto
Pazienza ormai sto facendo...mi serve di lezione, come del resto dicevate voi.
Per ora vediamo se riesco a completarlo a suon di processi e pipe.
Poi se tutto viene proverò a farlo normalmente, un "polling" diciamo.
Ho messo nuovi controlli.
Il bruco sbuca dai bordi del terminale in senso opposto, la testa che segue le direzioni e il fatto che se la testa tocca
il corpo muori... come nel gioco reale.
Poi mancherà la mela da mangiare e l'allungamento del bruco... ambiguo ma avete capito... come diceva Dario...
ti si allunga il bruco !!! :D :D

Download attachment
last_bruco.mp4 ( Number of downloads: 6 )

 
Top
159 replies since 6/1/2020, 21:09   1137 views
  Share