Программирование[9]

GoldRobot · 1 мая 2020

Это элайзор через фейк ствою статью пиарит?

nobodies · 1 мая 2020

на элазоре мир не сходится, активистов ШУЕ становится все больше во всех регионах и профессиях

E1azor · 1 мая 2020

GoldRobot написал 19 минут назад:

Это элайзор через фейк ствою статью пиарит?

не, там автор слишком жосткий троляка старой закалки, до него мне далеко

и у меня был в школе другой стиль прогания

MAIN.CPP

#include "param.h"
 #include "wind.h"
#include "defs.h"
#include "defone.h"
#include "vmemedit.h"
#include "vdouble.h"
#include "v3d.h"
#include "vfiles.h"
#include "_ddraw.h"
#include "_dsound.h"
#include "_win.h"
#include "main.h"

#define LEN2(tx1,ty1,tx2,ty2)    ((sqrt(SQR(SETXR2(tx1,tx2))+SQR(SETYR2(ty1,ty2)))))

int kol_mins=0,kol_post=0;

int START_NET_STAT=0;

/*******************************Главное*******************************/
int main(void)
{
if(start()==1)return 1;
///////////Zastavka///////////////////////////
//DSplay(S_START,DS_LOOP);
for(;;)
{
 settime();
  if(runwin()==1)break;
  setparam(pic1_zastavka.x, pic1_zastavka.y, 0, 0, pic1_zastavka.x-1, pic1_zastavka.y-1, pic1_zastavka.x*pic1_zastavka.y, 1);
  scaleKV(pic1_zastavka.buffer,0,0,pic1_zastavka.x-1,pic1_zastavka.y-1,win,WX1,WY1,WX2,WY2);
  if(putvb()==1)return 1;
  dela();
  if(keystat[VK_ESCAPE])break;
  if(keystat[VK_SPACE])break;  
 waittime(50);
}/*DSstop(S_START);DSplay(S_GAME,DS_LOOP);*/Sleep(500);
///////////Zastavka///////////////////////////

///////////Main///////////////////////////
for(;;)
{
 settime();
  if(runwin()==1)break;
  memset(keystat,0,sizeof(int)*256);
  if(run.lives>=1)
  if(NET_STAT==2)
  {
   if(run_ii()!=0)return 1;   
  }
   dela();
   if(keystat[VK_P])
   {
    for(;;)
    {
     keystat[VK_P]=of;dela();if(!keystat[VK_P])break; else Sleep(1);
	}
    for(;;)
    {
	 dela();if(keystat[VK_P] || keystat[VK_ESCAPE])break; else Sleep(1);
	}
    for(;;)
    {
     keystat[VK_P]=of;dela();if(!keystat[VK_P])break; else Sleep(1);
	}
   }
  if(keystat[VK_ESCAPE])break;
  if(keys()!=0)return 1;
  if(full_screen()!=0)return 1;
  if(otseku()!=0)return 1;
  if(key_and_fear()!=0)break;
  if(full_map_and_messages()!=0)return 1;  
  if(putvb()!=0)return 1;
 waittime(0);
}
///////////Main///////////////////////////

 if(end()==1)return 1;
 printf("\n<Ok>\n");
return 0;
}
/*********************************Конец*********************************/






/****************************************************************************/
/****************************************************************************/
/***********************************Карта и сообщения************************/
int full_map_and_messages(void)
{
int i;
///Map//////////////////////////////////
if(info.map==on && endg.stat==of)
{   
  int x0=WX/2-VIEWX/2,y0=WY/2-VIEWY/2-GY/4;
  for(i=0;i<KOL_AST;i++)
  {
   if(ast1[i].stat==on)psetB(MAPTOVIEWX(ast1[i].x),MAPTOVIEWY(ast1[i].y),28,win);
   if(ast2[i].stat==on)psetB(MAPTOVIEWX(ast2[i].x),MAPTOVIEWY(ast2[i].y),28,win);
   if(ast3[i].stat==on)psetB(MAPTOVIEWX(ast3[i].x),MAPTOVIEWY(ast3[i].y),28,win);
  }
  for(i=0;i<KOL_POST;i++)
  {
   if(post[i].stat==on)
   {
    setparam(pic1_map_post.x, pic1_map_post.y, 0, 0, pic1_map_post.x-1, pic1_map_post.y-1, pic1_map_post.x*pic1_map_post.y, 1);
	putP(pic1_map_post.buffer,0,0,pic1_map_post.x-1, pic1_map_post.y-1,win,MAPTOVIEWX(post[i].x)-pic1_map_post.x/2,MAPTOVIEWY(post[i].y)-pic1_map_post.y/2);
   }
  }
  for(i=0;i<KOL_SHLD;i++)
  {
   if(shld[i].stat==on)psetB(MAPTOVIEWX(shld[i].x),MAPTOVIEWY(shld[i].y),9,win);	   //
  }
  for(i=0;i<KOL_AMMO;i++)
  {
   if(ammo[i].stat==on)psetB(MAPTOVIEWX(ammo[i].x),MAPTOVIEWY(ammo[i].y),14,win);	   //
  }
  for(i=0;i<KOL_MINS;i++)
  {
   if(mins[i].stat==on)
   {   
    setparam(pic_mins.x, pic_mins.y, 0, 0, pic_mins.x-1, pic_mins.y-1, pic_mins.x*pic_mins.y, 1);      
    psetB(MAPTOVIEWX(mins[i].x),MAPTOVIEWY(mins[i].y),12,win);
   }
  }
  int c=RAND()%256;
   psetB(MAPTOVIEWX(run.x)-1,MAPTOVIEWY(run.y)-1,c,win);
   psetB(MAPTOVIEWX(run.x)-1,MAPTOVIEWY(run.y),c,win);
   psetB(MAPTOVIEWX(run.x),MAPTOVIEWY(run.y)-1,c,win);
   psetB(MAPTOVIEWX(run.x),MAPTOVIEWY(run.y),c,win);
    setparam(pic_map.x, pic_map.y, 0, 0, pic_map.x-1, pic_map.y-1, pic_map.x*pic_map.y, 1);
   putP(pic_map.buffer[0],0,0, pic_map.x-1, pic_map.y-1,win,x0-5,y0-5);
   putP(pic_map.buffer[1],0,0, pic_map.x-1, pic_map.y-1,win,x0+VIEWX-pic_map.x+5,y0-5);
   putP(pic_map.buffer[2],0,0, pic_map.x-1, pic_map.y-1,win,x0-5,y0+VIEWY-pic_map.y+5);
   putP(pic_map.buffer[3],0,0, pic_map.x-1, pic_map.y-1,win,x0+VIEWX-pic_map.x+5,y0+VIEWY-pic_map.y+5);
}
///Map//////////////////////////////////
///Messages//////////////////////////////////
setcharvoidcolor(0);
if(info.menu==on && endg.stat==of)
{
 printG(WX2-8*10,WY1,1,rus_mes[0],win);printGulong(WX2-8*5,WY1,1,(int)run.score,win);
 printG(WX1,WY2-8,1,rus_mes[1],win);printGulong(WX1+6*8,WY2-8,1,(int)run.lives,win);
 printG(WX/2-8*4,WY2-8,1,rus_mes[2],win);printGulong(WX/2+8*4,WY2-8,1,(int)run.shld,win);
 printG(WX2-8*11,WY2-8,1,rus_mes[3],win);printGulong(WX2-8*4,WY2-8,1,(int)run.ammo,win);  
 printG(WX1,WY1,1,"X:",win);printGulong(WX1+16,WY1,1,(int)run.x,win);
 printG(WX1,WY1+8,1,"Y:",win);printGulong(WX1+16,WY1+8,1,(int)run.y,win);  
 //printG(WX1,WY1+8*5,2,"G:",win);printGulong(WX1+16,WY1+8*5,2,(int)run.grad,win);  
}
if(umer.stat==on)
{
 printG(WX/2-8*7,WY/2+(UNER_MAX_COUNT-umer.count)*(GY/2)/UNER_MAX_COUNT,15,rus_mes[5],win);
 umer.count--;
 if(umer.count<=0)umer.stat=of;
}
if(endg.count>0)
{
 info.menu=of;
 info.map=of;
}
///Messages//////////////////////////////////
/* for(int i=1;i<1000;i++)
 {
  s=ast1[0];setparam(s.xpic, s.ypic, 0, 0, s.xpic-1, s.ypic-1, s.xpic*s.ypic, 1);
  int dl=10000/i;
  scaleKV(s.buffer[t],0,0,s.xpic-1,s.ypic-1,win,WX/2-dl,WY/2-dl,WX/2+dl,WY/2+dl);
  //scale(s.buffer[t],0,0,s.xpic-1,s.ypic-1,win,WX1+i,WY1+i,.01*i);  
   t++;if(t>16)t=0;   
 }*/ 
 if(kol_mins==0 && kol_post==0)
 {
  if(endg.count==0)
  {
   endg.count=WAIT_END;
   //DSplay(S_END);
  }
 }
kol_mins=0;kol_post=0;
///Messages//////////////////////////////////
return 0;
}
/***********************************Карта и сообщения************************/

/***********************************Клав->анимация***************************/
int key_and_fear(void)
{
FEAR fr;
RED_FEAR rf;
MINS m;
int i;
//FEAR/////////////////////////////////////
 if(endg.stat==of)
 if(keystat[VK_SPACE] || keystat[VK_CONTROL])
 {  
  if(run.ammo>0)
  {   
   //DSplaytempdouble(S_FEAR);
   if(fear_count>=KOL_FEAR)fear_count=0;
   initfear(fear_count++);
   run.ammo--;
  }
   else
  {
   //DSplay(S_EMPTY);
   //DSplaytempdouble(S_EMPTY);
  }
 }
 for(i=0;i<KOL_FEAR;i++)
 {
  if(fear[i].stat==on)
  {
   fr=fear[i];
    fr.x+=fr.dx;
	fr.y+=fr.dy;
	fr.count--;
   if(fr.count<=0)fr.stat=of;
   else
   {
if(info.screen==on)
{
    setparam(pic_fear.x, pic_fear.y, 0, 0, pic_fear.x-1, pic_fear.y-1, pic_fear.x*pic_fear.y, 1);
    putP(pic_fear.buffer[(FEAR_MAX_COUNT-fr.count-1)*pic_fear.kol/FEAR_MAX_COUNT],0,0,pic_fear.x-1,pic_fear.y-1,win,SETX((fr.x+pic_fear.x/2)),SETY((fr.y+pic_fear.y/2)));
}
   }
   fear[i]=fr;
  }
 }
//FEAR/////////////////////////////////////
///Karabl`//////////////////////////////////
 if(endg.stat==of)
 {
 if(run.shld <=0)
 {
  run.lives--;
  if(run.lives>0)
  {
   run.x=MAPX/2;
   run.y=MAPY/2;
   run.dx=0;
   run.dy=0;
   run.shld=SHLD_MAX;
   udar.count=0;
   //DSplay(S_UMER);
  }
  umer.stat=on;
  umer.count=UNER_MAX_COUNT;
  for(i=0;i<KOL_MINS;i++)
  {  
   if(mins[i].stat==on && mins[i].sleju==on)
   {
	mins[i].sleju=of;
    m.dx=RZNAK*(rand()%MINS_MAX_SPEED)/5;
    m.dy=RZNAK*(rand()%MINS_MAX_SPEED)/5;
   }
  }
 }
 if(run.lives<=0)
 {
  udar.count=3;
  if(endg.count==0)
  {
   endg.count=WAIT_END;endg.stat=on;
   //DSplay(S_END);
  }
 }
//setparam(pic_kar.x, pic_kar.y, 0, 0, pic_kar.x-1, pic_kar.y-1, pic_kar.x*pic_kar.y, 1);
//if(info.screen==on)kvadratB(SETX((run.x+pic_kar.x/2)),SETY((run.y+pic_kar.y/2)),SETX((run.x-pic_kar.x/2)),SETY((run.y-pic_kar.y/2)),1,win);
  setparam(pic_kar.x, pic_kar.y, 0, 0, pic_kar.x-1, pic_kar.y-1, pic_kar.x*pic_kar.y, 1);
  putP(pic_kar.buffer[(int)(run.grad/DGRAD-4+16)%16+run.go*16],0,0,pic_kar.x-1,pic_kar.y-1,win,WX/2-pic_kar.x/2,WY/2-pic_kar.y/2);
  if(udar.count<3)
  {
   setparam(pic_udar.x, pic_udar.y, 0, 0, pic_udar.x-1, pic_udar.y-1, pic_udar.x*pic_udar.y, 1);
   putP(pic_udar.buffer[udar.count],0,0,pic_udar.x-1,pic_udar.y-1,win,WX/2-pic_udar.x/2,WY/2-pic_udar.y/2);
   udar.count++;
  }
 }
 if(endg.stat==on || endg.count>0)
 {
  endg.count--;if(endg.count<=0)return 1;//break;
 }
///Karabl`//////////////////////////////////
///Red Fear//////////////////////////////////
 for(i=0;i<KOL_RED_FEAR;i++)
 if(red_fear[i].stat==on)
 {
  rf=red_fear[i];
  rf.x+=rf.dx;
  rf.y+=rf.dy;
  if(rf.x<0)rf.x=MAPX-1;if(rf.x>=MAPX)rf.x=0;
  if(rf.y<0)rf.y=MAPY-1;if(rf.y>=MAPY)rf.y=0;
  rf.count--;
  if(rf.count<=0)rf.stat=of;
  else
  {   
   if(info.screen==on)
   {
	setparam(pic_red_fear.x, pic_red_fear.y, 0, 0, pic_red_fear.x-1, pic_red_fear.y-1, pic_red_fear.x*pic_red_fear.y, 1);
    scale(pic_red_fear.buffer[(rf.max_count-rf.count)*pic_red_fear.kol/rf.max_count],0,0,pic_red_fear.x-1, pic_red_fear.y-1,win,SETX((rf.x+(int)(pic_red_fear.x*rf.xscale/2))),SETY((rf.y+(pic_red_fear.y*rf.xscale/2))),rf.xscale);
    //scale(pic_red_fear.buffer[(rf.max_count-rf.count)*pic_red_fear.kol/rf.max_count],0,0,pic_red_fear.x-1, pic_red_fear.y-1,win,SETX((rf.x+(int)(pic_red_fear.x))),SETY((rf.y+(pic_red_fear.y))),rf.xscale);
    //scaleKV(pic_red_fear.buffer[(rf.max_count-rf.count)*pic_red_fear.kol/rf.max_count],0,0,pic_red_fear.x-1, pic_red_fear.y-1,win,SETX((rf.x+pic_red_fear.x/2)),SETY((rf.y+pic_red_fear.y/2)),SETX((rf.x+pic_red_fear.x/2))+pic_red_fear.x*2,SETY((rf.y+pic_red_fear.y/2))+pic_red_fear.x*2);
    //   putP(pic_red_fear.buffer[(rf.max_count-rf.count)*pic_red_fear.kol/rf.max_count],0,0, pic_red_fear.x-1, pic_red_fear.y-1,win,SETX((rf.x+pic_red_fear.x/2)),SETY((rf.y+pic_red_fear.y/2)));
   }
  }
  red_fear[i]=rf;
 }
///Red Fear//////////////////////////////////
return 0;
}
/***********************************Клав->анимация***************************/

/***********************************Столкновения*****************************/
int otseku(void)
{
int i,j;
AST a;
POST p;
SHLD s;
AMMO am;
FEAR fr;
MINS m;
//OTSEKY!/////////////////////////////////////
/////////KARABL`/////////////////
if(endg.stat==of)
{
 for(j=0;j<3;j++)
 for(i=0;i<KOL_AST;i++)
 {
  if(j==0)a=ast1[i];
  if(j==1)a=ast2[i]; 
  if(j==2)a=ast3[i];
  if(a.stat==on)
  {
   if(LEN(a.x,a.y)<sqrt(SQR((pic_ast[j].x/2))+SQR((pic_kar.x/2))))
   {
    run.shld-=(4-j)*4;
	int ttt;
	ttt=-5-j+(rand()%(9+j*2)+1);if(ttt!=0)run.dx/=ttt;
	ttt=-5-j+(rand()%(9+j*2)+1);if(ttt!=0)run.dy/=ttt;
    run.grad+=RZNAK*DGRAD*(rand()%(j+1));
	if(run.grad<0)run.grad+=360;
    if(run.grad>=360)run.grad-=360;
	//DSplay(S_UDAR);
	//DSplaytempdouble(S_UDAR);
    udar.count=0;
    a.stat=of;
    if(j==0)ast1[i]=a;
    if(j==1)ast2[i]=a;
    if(j==2)ast3[i]=a;
   }
  }
 }
 for(i=0;i<KOL_MINS;i++)
 {
  m=mins[i];
  if(m.stat==on && mins[i].sleju==of)
  {
   if(LEN(m.x,m.y)<sqrt(SQR((pic_mins.x/2))+SQR((pic_kar.x/2)))+MINS_MIN_LEN)
   {
    mins[i].sleju=on;
	//DSplay(S_SLEJU);//DSplaytempdouble(S_SLEJU);
   }
   else
   if(i<KOL_POST && post[i].stat==on)
   if((int)mins[i].x!=post[i].x || (int)mins[i].y!=post[i].y)
   {
	double dx,dy,dl;
    dx=SETXR2(post[i].x,mins[i].x);
    dy=SETYR2(post[i].y,mins[i].y);
	dl=sqrt(SQR(dx)+SQR(dy));
    mins[i].dx=MINS_MAX_SPEED*MINS_MAX_DSPEEDX*dx/dl;
    mins[i].dy=MINS_MAX_SPEED*MINS_MAX_DSPEEDY*dy/dl;
   }
  }
  if(m.stat==on && m.sleju==on)
  {
   double dx,dy,dl;
   dx=SETXR(mins[i].x);
   dy=SETYR(mins[i].y);
   dl=sqrt(SQR(dx)+SQR(dy));
//!!!!!!!!!
   if(dl<pic_mins.x*2)
   {
    mins[i].dx+=MINS_MAX_DSPEEDX*dx/dl/2.;
    mins[i].dy+=MINS_MAX_DSPEEDY*dy/dl/2.;
   }
    else
   {
    mins[i].dx=MINS_MAX_SPEED*MINS_MAX_DSPEEDX*dx/dl;
    mins[i].dy=MINS_MAX_SPEED*MINS_MAX_DSPEEDY*dy/dl;
   }
    //mins[i].dx=MINS_MAX_SPEED*MINS_MAX_DSPEEDX*dx/dl;
    //mins[i].dy=MINS_MAX_SPEED*MINS_MAX_DSPEEDY*dy/dl;
//!!!!!!!!!
   if(dl<sqrt(SQR((pic_mins.x/2))+SQR((pic_kar.x/2))))
   {
    run.shld-=mins[i].shldmm+mins[i].shld/10;
	//DSplay(S_KARMM);
	//DSplaytempdouble(S_KARMM);
	mins[i].stat=of;
	if(i<KOL_POST)
	if(post[i].stat==on)
	{
	 post[i].count=MINS_MAX_COUNT;	 
	}
    udar.count=0;
   }//(Vzr)
  }
 }
 for(i=0;i<KOL_AMMO;i++)
 {
  am=ammo[i];
  if(am.stat==on)
  if(LEN(am.x,am.y)<sqrt(SQR((pic1_ammo.x/2))+SQR((pic_kar.x/2))))
  {
   run.ammo+=am.ammopp;
   ammo[i].stat=of;
   //DSplaytempdouble(S_AMMO);
  }
 }
 for(i=0;i<KOL_SHLD;i++)
 {
  s=shld[i];
  if(s.stat==on)
  if(LEN(s.x,s.y)<sqrt(SQR((pic1_shld.x/2))+SQR((pic_kar.x/2))))
  {
   run.shld+=s.shldpp;if(run.shld>SHLD_MAX)run.shld=SHLD_MAX;
   shld[i].stat=of;   
   //DSplaytempdouble(S_SHLD);
  }
 }
}
/////////FEAR://
/*VERY LONG!!!!!!!!!!!!!************************************/
for(int t=0;t<KOL_FEAR;t++)
{
 if(fear[t].stat==on)
 {
  fr=fear[t];
/*  int x=SETX(fr.x),y=SETY(fr.y);
  if(x>=WX1 && x<WX2)
  if(y>=WY1 && y<WY2)
  {*/
//   if(win[y*WX+x]!=0)
//ASTER///////////////
for(j=0;j<3;j++)
for(i=0;i<KOL_AST;i++)
{
 if(j==0)a=ast1[i];
 if(j==1)a=ast2[i];
 if(j==2)a=ast3[i];
 if(a.stat==on)
 {  
  if(LEN2(a.x,a.y,fr.x,fr.y)<sqrt(SQR((pic_ast[j].x/2))+SQR((pic_fear.x/2))))
  {
   a.stat=of;
   if(j==0)ast1[i]=a;
   if(j==1)ast2[i]=a;
   if(j==2)ast3[i]=a;
   initred_fear(a.x+RZNAK*rand()%(pic_ast[j].x/2), a.y+RZNAK*rand()%(pic_ast[j].y/2), a.dx, a.dy, RED_FEAR_MAX_COUNT);
   //DSplaytempdouble(S_RED_FEAR_M);
   run.score+=SCORE_AST;   
   fr.stat=of;
    int r;
	r=(rand()%3);
    if(j<=0)for(int t=1;t<=r;t++)
    for(i=0;i<KOL_AST;i++)
	{
     if(ast2[i].stat==of)
	 {
      AST s=a;
      s.x+=RZNAK*(RAND()%15);
	  s.y+=RZNAK*(RAND()%15);
      s.dx=-AST_MAX_SPEED/2+RAND()%AST_MAX_SPEED;
      s.dy=-AST_MAX_SPEED/2+RAND()%AST_MAX_SPEED;
      s.stat=on; 
      s.pic_speed=RZNAK*(RAND()%100)/100.;  
      s.pic_stat=RAND()%AST2_KOLPIC;
      ast2[i]=s;
      break;
	 }
    }
	r=(rand()%3);
    if(j<=1)for(int t=1;t<=r;t++)
    for(i=0;i<KOL_AST;i++)
	{
     if(ast3[i].stat==of)
	 {
      AST s=a;
      s.x+=RZNAK*(RAND()%15);
	  s.y+=RZNAK*(RAND()%15);
      s.dx=-AST_MAX_SPEED/2+RAND()%AST_MAX_SPEED;
      s.dy=-AST_MAX_SPEED/2+RAND()%AST_MAX_SPEED;
      s.stat=on; 
      s.pic_speed=RZNAK*(RAND()%100)/100.;  
      s.pic_stat=RAND()%AST3_KOLPIC;
      ast3[i]=s;
      break;
	 }
    }
   goto br;
  }
 }
}
//ASTER///////////////
//POSTS///////////////
for(i=0;i<KOL_POST;i++)
{
 p=post[i];
 if(p.stat==on)
 {
  if(LEN2(p.x,p.y,fr.x,fr.y)<sqrt(SQR((pic_post.x/2))+SQR((pic_fear.x/2))))
  {   
   post[i].shld--;
   initred_fear(post[i].x+RZNAK*rand()%(pic_post.x/2), post[i].y+RZNAK*rand()%(pic_post.y/2), 0, 0, RED_FEAR_MAX_COUNT);
   //DSplaytempdouble(S_RED_FEAR_P);
   if(post[i].shld<=0)
   {
    run.ammo+=post[i].ammopp;
    run.shld+=post[i].shldpp;
	//if(post[i].ammopp>100)DSplay(S_AMMO);
	//if(post[i].shldpp>30) DSplay(S_SHLD);
	//DSplay(S_POSTMM);
	if(run.shld>SHLD_MAX)run.shld=SHLD_MAX;
	run.score+=SCORE_POST;
    post[i].stat=of;
   }
   fr.stat=of;
  }
 }
}
//POSTS///////////////
//MINS///////////////
for(i=0;i<KOL_MINS;i++)
{
 m=mins[i];
 if(m.stat==on)
 {
  if(LEN2(m.x,m.y,fr.x,fr.y)<sqrt(SQR((pic_mins.x/2))+SQR((pic_mins.x/2))))
  {   
   mins[i].shld--;
   initred_fear((int)(mins[i].x)+RZNAK*rand()%(pic_mins.x/2), (int)(mins[i].y)+RZNAK*rand()%(pic_mins.y/2), (int)mins[i].dx, (int)mins[i].dy, RED_FEAR_MAX_COUNT);   
   //DSplaytempdouble(S_RED_FEAR_M);
   if(mins[i].shld<=0)
   {    
	run.score+=SCORE_MINA;
    mins[i].stat=of;
	if(i<KOL_POST)
	if(post[i].stat==on)
	{
	 post[i].count=MINS_MAX_COUNT;	 
	}
   }
   fr.stat=of;
  }
 }
}
//MINS///////////////
br:;
   //win[y*WX+x]=15;
//  }
  fear[t]=fr;
 }
}
/*VERY LONG!!!!!!!!!!!!!************************************/
/////////FEAR://
//OTSEKY!/////////////////////////////////////
return 0;
}
/***********************************Столкновения*****************************/

/***********************************Анимация*********************************/
int full_screen(void)
{
int i,j;
AST a;
POST p;
SHLD s;
AMMO am;
PIXEL pi;
MINS m;
///Nebo//////////////////////////////////
if(info.screen==on)
for(i=0;i<KOLZV;i++)
{
 psetB(WX1+(zvx[0][i]+(int)run.x/2)%NX,WY1+(zvy[0][i]+(int)run.y/2)%NY,15,win);
 psetB(WX1+(zvx[1][i]+(int)run.x/4)%NX,WY1+(zvy[1][i]+(int)run.y/4)%NY,7,win);
 psetB(WX1+(zvx[2][i]+(int)run.x/8)%NX,WY1+(zvy[2][i]+(int)run.y/8)%NY,8,win);
}
///Nebo//////////////////////////////////
///Post//////////////////////////////////
  for(i=0;i<KOL_POST;i++)
  if(post[i].stat==on)
  {
   kol_post++;
   p=post[i];
   p.pic_stat++;   
    if((int)p.pic_stat/10>=pic_post.kol)p.pic_stat=0;      
   if(p.count>0)
   {	
    p.count--;
	if(p.count==0)initmins(i);
   }
if(info.screen==on)
{
   setparam(pic_post.x, pic_post.y, 0, 0, pic_post.x-1, pic_post.y-1, pic_post.x*pic_post.y, 1);  
//if(info.screen==on)kvadratB(SETX((p.x+pic_post.x/2)),SETY((p.y+pic_post.y/2)),SETX((p.x-pic_post.x/2)),SETY((p.y-pic_post.y/2)),1,win);
   putP(pic_post.buffer[(int)p.pic_stat/10],0,0, pic_post.x-1, pic_post.y-1,win,SETX((p.x+pic_post.x/2)),SETY((p.y+pic_post.y/2)));
}
   post[i]=p;
  }
///Post//////////////////////////////////
///MINS//////////////////////////////////
  for(i=0;i<KOL_MINS;i++)
  if(mins[i].stat==on)
  {   
   kol_mins++;
   m=mins[i];
   m.pic_stat++;
   if(!(m.dx==0 && m.dy==0))
   if(rand()%100==0)
   {
	m.dx+=RZNAK*MINS_MAX_DSPEEDX;
	m.dy+=RZNAK*MINS_MAX_DSPEEDY;
   }
   m.x+=m.dx;
   m.y+=m.dy;
   if(m.x<0)m.x=MAPX-1;if(m.x>=MAPX)m.x=0;
   if(m.y<0)m.y=MAPY-1;if(m.y>=MAPY)m.y=0;
    if((int)m.pic_stat/10>=pic_mins.kol)m.pic_stat=0;      
if(info.screen==on)
{
   setparam(pic_mins.x, pic_mins.y, 0, 0, pic_mins.x-1, pic_mins.y-1, pic_mins.x*pic_mins.y, 1);  
   putP(pic_mins.buffer[(int)m.pic_stat/10],0,0, pic_mins.x-1, pic_mins.y-1,win,SETX((m.x+pic_mins.x/2)),SETY((m.y+pic_mins.y/2)));
}
   mins[i]=m;
  }
///MINS//////////////////////////////////
///SHLD//////////////////////////////////
  for(i=0;i<KOL_SHLD;i++)
  {
   if(shld[i].stat==on)
   {
	s=shld[i];
	if(rand()%SHLD_CHAST==0)
    {
	 s.dx+=RZNAK;
	 s.dy+=RZNAK;
	}
	if(ABS(s.dx)>SHLD_MAX_SPEED)s.dx/=2;
	if(ABS(s.dy)>SHLD_MAX_SPEED)s.dy/=2;
    s.x+=s.dx;
	s.y+=s.dy;
    if(s.x>=MAPX)s.x=0;
    if(s.x<0)s.x=MAPX-1;
    if(s.y>=MAPY)s.y=0;
    if(s.y<0)s.y=MAPY-1;
    shld[i]=s;      
	if(info.screen==on)
	{
      setparam(pic1_shld.x, pic1_shld.y, 0, 0, pic1_shld.x-1, pic1_shld.y-1, pic1_shld.x*pic1_shld.y, 1);
      putP(pic1_shld.buffer,0,0, pic1_shld.x-1, pic1_shld.y-1,win,SETX((s.x+pic1_shld.x/2)),SETY((s.y+pic1_shld.y/2)));
	}
   }
  }
///SHLD//////////////////////////////////
///AMMO//////////////////////////////////
  for(i=0;i<KOL_AMMO;i++)
  {
   if(ammo[i].stat==on)
   {
	am=ammo[i];
	if(rand()%AMMO_CHAST==0)
    {
     am.dx+=RZNAK;
     am.dy+=RZNAK;
	}
	if(ABS(am.dx)>AMMO_MAX_SPEED)am.dx/=2;
	if(ABS(am.dy)>AMMO_MAX_SPEED)am.dy/=2;
    am.x+=am.dx;
	am.y+=am.dy;
    if(am.x>=MAPX)am.x=0;
    if(am.x<0)am.x=MAPX-1;
    if(am.y>=MAPY)am.y=0;
    if(am.y<0)am.y=MAPY-1;
    ammo[i]=am;      
	if(info.screen==on)
	{
      setparam(pic1_ammo.x, pic1_ammo.y, 0, 0, pic1_ammo.x-1, pic1_ammo.y-1, pic1_ammo.x*pic1_ammo.y, 1);
      putP(pic1_ammo.buffer,0,0, pic1_ammo.x-1, pic1_ammo.y-1,win,SETX((am.x+pic1_ammo.x/2)),SETY((am.y+pic1_ammo.y/2)));
	}
   }
  }
///AMMO//////////////////////////////////
///Aster//////////////////////////////////
  for(j=0;j<3;j++)
  for(i=0;i<KOL_AST;i++)
  {
   if(j==0)a=ast1[i];
   if(j==1)a=ast2[i];
   if(j==2)a=ast3[i];
   if(a.stat==on)
   {
    a.x+=a.dx;
    a.y+=a.dy;
    a.pic_stat+=a.pic_speed;
     if(a.x>=MAPX)a.x=0;
     if(a.x<0)a.x=MAPX-1;
     if(a.y>=MAPY)a.y=0;
     if(a.y<0)a.y=MAPY-1;
     if((int)a.pic_stat<=0)a.pic_stat+=pic_ast[j].kol;
     if((int)a.pic_stat>=pic_ast[j].kol)a.pic_stat-=(double)pic_ast[j].kol;      
//if(info.screen==on)
//kvadratB(SETX((a.x+pic_ast[j].x/2)),SETY((a.y+pic_ast[j].y/2)),SETX((a.x-pic_ast[j].x/2)),SETY((a.y-pic_ast[j].y/2)),2,win);
	if(info.screen==on)
	{
     setparam(pic_ast[j].x, pic_ast[j].y, 0, 0, pic_ast[j].x-1, pic_ast[j].y-1, pic_ast[j].x*pic_ast[j].y, 1);
     putP(pic_ast[j].buffer[(int)a.pic_stat],0,0, pic_ast[j].x-1, pic_ast[j].y-1,win,SETX((a.x+pic_ast[j].x/2)),SETY((a.y+pic_ast[j].y/2)));
	}
    if(j==0)ast1[i]=a;
    if(j==1)ast2[i]=a;
    if(j==2)ast3[i]=a;
   }
  }
///Aster//////////////////////////////////
//PIXELS/////////////////////////////////////
 if(run.go==on)
 {
  if(pixel_count>=KOL_PIXEL)pixel_count=0;
  initpixel(pixel_count++);
 }
 for(i=0;i<KOL_PIXEL;i++)
 {
  if(pixel[i].stat==on)
  {
   pi=pixel[i];
    pi.x+=pi.dx;
	pi.y+=pi.dy;
	pi.count--;if(pi.count<=0)pi.stat=of;else
if(info.screen==on)
    psetB(SETX(pi.x),SETY(pi.y),100,win);
   pixel[i]=pi;
  }
 }
//PIXELS/////////////////////////////////////
return 0;
}
/***********************************Анимация*********************************/

/*********************************Клавиатура*********************************/
int keys(void)
{
  save_run_x=run.x;
  save_run_y=run.y;  
  run.go=of;  
 if(keystat[VK_INC] && GetTickCount()-info.time_pp>10)
 {   
  VIEWX+=2;VIEWY+=2;info.time_pp=GetTickCount();  
 }
 if(keystat[VK_DEC] && GetTickCount()-info.time_pp>10)
 {   
  VIEWX-=2;VIEWY-=2;info.time_pp=GetTickCount();  
 }
 if(keystat[VK_TAB] && GetTickCount()-info.time_tab>100)
 {
  if(START_NET_STAT==2)
  {
   if(NET_STAT==0)NET_STAT=START_NET_STAT;else NET_STAT=0;
   info.time_tab=GetTickCount();   
  }
 }
 if(keystat[VK_S] && GetTickCount()-info.time>100)
 {
  info.screen=1-info.screen;info.time=GetTickCount();
  //DSplay(S_MENU);
 }
 if(keystat[VK_M] && GetTickCount()-info.time>100)
 {
  info.map=1-info.map;info.time=GetTickCount();
  //DSplay(S_MENU);
 }
 if(keystat[VK_I] && GetTickCount()-info.time>100)
 {
  info.menu=1-info.menu;info.time=GetTickCount();
  //DSplay(S_MENU);
 }  
 if(keystat[VK_F1] && GetTickCount()-info.time>100 && info.speed<10){info.speed++;info.time=GetTickCount();}
 if(keystat[VK_F2] && GetTickCount()-info.time>100 && info.speed>0){info.speed--;info.time=GetTickCount();}
 if(endg.stat==of)
 {
  if(keystat[VK_F10])
  {
   udar.count=0;
   if(endg.count==0)
   {
    endg.count=WAIT_END;
    //DSplay(S_END);
   }
  }
  if(keystat[VK_LEFT]){run.grad-=DGRAD;}
  if(keystat[VK_RIGHT]){run.grad+=DGRAD;}
  if(keystat[VK_UP])  
  {
   run.dx+=KAR_MAX_DSPEEDX*COS(run.grad);
   run.dy+=KAR_MAX_DSPEEDY*SIN(run.grad);
   run.go=on;
  }
  if(keystat[VK_DOWN])
  {
   run.dx-=KAR_MAX_DSPEEDX*COS(run.grad);
   run.dy-=KAR_MAX_DSPEEDY*SIN(run.grad);
   run.go=on;
  }
  if(keystat[VK_LSHIFT]){run.dx/=KAR_PRAVKA;run.dy/=KAR_PRAVKA;}
  if(keystat[VK_UP] || keystat[VK_DOWN])
  {   
   //DSplay(S_GO);//DSplaytempdouble(S_GO);
  }
   else
  {
   //DSstop(S_GO);
  }
  if(run.grad<0)run.grad+=360;
  if(run.grad>=360)run.grad-=360;  
  if(sqrt(SQR(run.dx/4)+SQR(run.dy/3)>=KAR_MAX_SPEED))
  {
   run.dx/=KAR_PRAVKA;
   run.dy/=KAR_PRAVKA;
  }
  if(rand()%100==0 && run.shld<SHLD_MAX)run.shld++;
 }
  run.x+=run.dx;
  run.y+=run.dy;
 if(run.x<0)run.x+=MAPX;
 if(run.x>=MAPX)run.x-=MAPX;
 if(run.y<0)run.y+=MAPY;
 if(run.y>=MAPY)run.y-=MAPY;    
return 0;
}
/*********************************Клавиатура*********************************/

/*********************************Дела*********************************/
void dela(void)
{ 
 ADDKEY(VK_UP);
 ADDKEY(VK_DOWN);
 ADDKEY(VK_LEFT);
 ADDKEY(VK_RIGHT);
 ADDKEY(VK_CONTROL);
 ADDKEY(VK_LSHIFT);
 ADDKEY(VK_SPACE);
 ADDKEY(VK_ESCAPE);
 ADDKEY(VK_F10);
 ADDKEY(VK_F1);
 ADDKEY(VK_F2); 
 ADDKEY(VK_S);
 ADDKEY(VK_I);
 ADDKEY(VK_M);
 ADDKEY(VK_INC);
 ADDKEY(VK_DEC);
 ADDKEY(VK_TAB);
 ADDKEY(VK_P);
//for(int i=0;i<256;i++)if(KEYDOWN(i))printf("%d\n",i);
}
/*********************************Дела*********************************/

/*********************************Инициализация*********************************/
int start(void)
{
FILE *f;
char str[1001];
int i,j;
srand(GetTickCount());
///Init Win///////////////////////////////////////////// 
 if(setwin()!=0){printf("Win Err\n");return 1;} 
///Set Klav///////////////////////////////////////////// 
 memset(keystat,0,sizeof(int)*256);
 kolpics=0;
///CONST INIT!!!////////////////////
f=fopen("param.DAT","r");if(f==NULL)return 1;
{
 double m[100];
 char c;
 for(i=1;!feof(f);i++)
 { 
  for(;!feof(f);)
  {
   c=getc(f);//if(c>='0' && c<='9')break;
   if(c=='#')break;
  }
   fscanf(f,"%lf",&m[i]);
  for(;getc(f)!='\n';)if(feof(f))break;  
  printf("%lf\n",m[i]);
 }
fclose(f);
i=1;
 NET_STAT=(int)m[i];i++;START_NET_STAT=NET_STAT;
 NET_TICK=(int)m[i];i++;
 VIEWX=(int)m[i];i++;
 VIEWY=(int)m[i];i++;
 KOL_SHLD=(int)m[i];i++;
 KOL_AMMO=(int)m[i];i++;
 KOL_MINS =(int)m[i];i++;
 KOL_AST  =(int)m[i];i++;
 KOL_POST =(int)m[i];i++;
 KOL_PIXEL=(int)m[i];i++;
 KOL_FEAR =(int)m[i];i++;
 KOL_RED_FEAR=(int)m[i];i++;
 MINS_KOLPIC=(int)m[i];i++;
 AST1_KOLPIC=(int)m[i];i++;
 AST2_KOLPIC=(int)m[i];i++;
 AST3_KOLPIC=(int)m[i];i++;
 POST_KOLPIC=(int)m[i];i++;
 SHLD_MAX     	=(int)m[i];i++;
	AMMO_BEGIN     	=(int)m[i];i++;
 MINS_MIN_SHLD	=(int)m[i];i++;
	MINS_RAND_SHLD	=(int)m[i];i++;
 MINS_MIN_SHLDMM=(int)m[i];i++;
	MINS_RAND_SHLDMM=(int)m[i];i++;
		MINS_MAX_COUNT=(int)m[i];i++;
 MINS_MIN_LEN   =(int)m[i];i++; 
 MINS_MAX_DSPEEDX=m[i];i++;
 MINS_MAX_DSPEEDY=m[i];i++;
 MINS_MAX_SPEED  =(int)m[i];i++;
 AST_MAX_SPEED	 =(int)m[i];i++;
 POST_MIN_AMMOPP =(int)m[i];i++;
	POST_RAND_AMMOPP =(int)m[i];i++;
 POST_MIN_SHLDPP =(int)m[i];i++;
	POST_RAND_SHLDPP =(int)m[i];i++;
 POST_MIN_SHLD	 =(int)m[i];i++;
	POST_RAND_SHLD	 =(int)m[i];i++;
  SHLD_MIN_SHLDPP=(int)m[i];i++;
	SHLD_RAND_SHLDPP=(int)m[i];i++;
  SHLD_MAX_SPEED =(int)m[i];i++;  
  SHLD_CHAST     =(int)m[i];i++;
  AMMO_MIN_AMMOPP=(int)m[i];i++;
	AMMO_RAND_AMMOPP=(int)m[i];i++;
  AMMO_MAX_SPEED =(int)m[i];i++;
  AMMO_CHAST     =(int)m[i];i++;
 KAR_MAX_SPEED	 =(int)m[i];i++;
 KAR_MAX_DSPEEDX =m[i];i++;
 KAR_MAX_DSPEEDY =m[i];i++;
 KAR_PRAVKA      =m[i];i++;
 PIXEL_SPEEDX      =(int)m[i];i++;
 PIXEL_SPEEDY      =(int)m[i];i++;
 PIXEL_MAX_COUNT   =(int)m[i];i++;
 FEAR_MAX_COUNT    =(int)m[i];i++;
 FEAR_SPEEDX       =(int)m[i];i++;
 FEAR_SPEEDY       =(int)m[i];i++;
 RED_FEAR_MAX_COUNT=(int)m[i];i++;
 WAIT_END       =(int)m[i];i++;
 UNER_MAX_COUNT =(int)m[i];i++;
 SCORE_AST      =(int)m[i];i++;
 SCORE_MINA     =(int)m[i];i++;
 SCORE_POST     =(int)m[i];i++;
}
mins=new MINS[KOL_MINS];
ast1=new AST[KOL_AST];
ast2=new AST[KOL_AST];
ast3=new AST[KOL_AST];
post=new POST[KOL_POST];
shld=new SHLD[KOL_SHLD];
ammo=new AMMO[KOL_AMMO];
pixel=new PIXEL[KOL_PIXEL];
fear=new FEAR[KOL_FEAR];
red_fear=new RED_FEAR[KOL_RED_FEAR];
memset(mins,0,KOL_MINS*sizeof(MINS_typ));
memset(ast1,0,KOL_AST*sizeof(AST_typ));
memset(ast2,0,KOL_AST*sizeof(AST_typ));
memset(ast3,0,KOL_AST*sizeof(AST_typ));
memset(post,0,KOL_POST*sizeof(POST_typ));
memset(shld,0,KOL_SHLD*sizeof(SHLD_typ));
memset(ammo,0,KOL_AMMO*sizeof(AMMO_typ));
memset(pixel,0,KOL_PIXEL*sizeof(PIXEL_typ));
memset(fear,0,KOL_FEAR*sizeof(FEAR_typ));
memset(red_fear,0,KOL_RED_FEAR*sizeof(RED_FEAR_typ));
///CONST INIT!!!////////////////////
///BMP LOADING//////////////////////
f=fopen("pic.DAT","r");if(f==NULL)return 1;
while(!feof(f))
{
 gets(f,str,1000);if(feof(f))break;
 printf("%s",str);
 if(loadBMP(str,&pics[kolpics])==0)
 {
  printf(" Len=%d,X=%d,Y=%d,Bits=%d,Pal=%d",(int)pics[kolpics].len,
	                                        (int)pics[kolpics].x,
	  									    (int)pics[kolpics].y,
	  									    (int)pics[kolpics].bits,
	    									(int)pics[kolpics].pal==NULL?0:1);
  printf(" OK\n");
 }
 else 
 {
  printf(" !Not!\n");
 }
 kolpics++;
}
fclose(f);
///RUS LOADING//////////////////////
f=fopen("rus.DAT","r");if(f==NULL)return 1;
for(i=0;!feof(f);i++)
{
 gets(f,rus_mes[i],100);
}
fclose(f);
///RUS LOADING//////////////////////
///BMP LOADING//////////////////////
loadLB("asc.bin",char8x8,2048L);
///GET TEXTS//////////////////////
if(pics[PIC_SCREEN].pal!=NULL){memcopy((uchar *)pics[PIC_SCREEN].pal,(uchar *)pal,256*sizeof(RGB));}
//if(setpalette(pal)==1)return 1;
////SPRITES////////////////////////////////////////////
int t=0;
////MINS////////////////////////////////////////////
 pic_mins.x=pics[t].x;
 pic_mins.y=pics[t].y;
 pic_mins.kol=MINS_KOLPIC;  
for(i=0;i<MINS_KOLPIC;i++)
{
 pic_mins.buffer[i]=pics[t].buffer; t++; 
}
////<AST>////////////////////////////////////////////
////<AST>////////////////////////////////////////////
 pic_ast[0].x=pics[t].x;
 pic_ast[0].y=pics[t].y;
 pic_ast[0].kol=AST1_KOLPIC;  
for(i=0;i<AST1_KOLPIC;i++)
{
 pic_ast[0].buffer[i]=pics[t].buffer; t++; 
}
 pic_ast[1].x=pics[t].x;
 pic_ast[1].y=pics[t].y;
 pic_ast[1].kol=AST2_KOLPIC;  
for(i=0;i<AST2_KOLPIC;i++)
{
 pic_ast[1].buffer[i]=pics[t].buffer; t++; 
}
 pic_ast[2].x=pics[t].x;
 pic_ast[2].y=pics[t].y;
 pic_ast[2].kol=AST3_KOLPIC;  
for(i=0;i<AST3_KOLPIC;i++)
{
 pic_ast[2].buffer[i]=pics[t].buffer; t++; 
}
 pic_post.x=pics[t].x;
 pic_post.y=pics[t].y;
 pic_post.kol=POST_KOLPIC;
for(i=0;i<POST_KOLPIC;i++)
{
 pic_post.buffer[i]=pics[t].buffer; t++; 
}

pic1_zastavka.x=pics[t].x;
pic1_zastavka.y=pics[t].y;
pic1_zastavka.buffer=pics[t].buffer; t++;

//MAP//
 Gettexts(&pics[t],0,0,4,1,24,24,4,pic_map.buffer);
 pic_map.kol=4;
 pic_map.x=24;
 pic_map.y=24; 
 t++;
//MAP//
//KARABL'// 
 Gettexts(&pics[t],0,0,8,4,64,64,32,pic_kar.buffer);
 pic_kar.kol=32;
 pic_kar.x=64;
 pic_kar.y=64;  
 Gettexts(&pics[t],0,65*4,3,1,64,64,3,pic_udar.buffer);
 pic_udar.kol=3;
 pic_udar.x=64;
 pic_udar.y=64;
 t++;
//KARABL'//
//FEAR//
 Gettexts(&pics[t],0,0,8,1,16,16,8,pic_fear.buffer);
 pic_fear.kol=8;
 pic_fear.x=16;
 pic_fear.y=16;
 t++;
//POST_MAP//
 //Gettexts(&pics[t],0,0,1,1,7,7,1,pic1_map_post.buffer);
 pic1_map_post.buffer=pics[t].buffer;
 pic1_map_post.x=8;
 pic1_map_post.y=8;
 t++; 
//RED FEAR///
 Gettexts(&pics[t],0,0,6,4,42,36,14,pic_red_fear.buffer); 
 pic_red_fear.kol=14;
 pic_red_fear.x=42;
 pic_red_fear.y=36;
 t++;
//SHLD///
 pic1_shld.buffer=pics[t].buffer;
 pic1_shld.x=32;
 pic1_shld.y=32;
 t++;
//AMMO///
 pic1_ammo.buffer=pics[t].buffer;
 pic1_ammo.x=32;
 pic1_ammo.y=32;
 t++;
//END load



for(i=0;i<KOL_AST/4;i++)
{
 initast(i,1);initast(i,2);initast(i,3);
}
for(i=0;i<KOL_POST;i++)
{
 initpost(i);
}
for(i=0;i<KOL_MINS;i++)
{
 initmins(i);
}
for(i=0;i<KOL_SHLD;i++)
{
 initshld(i);
}
for(i=0;i<KOL_AMMO;i++)
{
 initammo(i);
}
run.x=MAPX/2;
run.y=MAPY/2;
run.dx=0;
run.dy=0;
run.grad=90;
run.lives=3;
run.ammo=AMMO_BEGIN;
run.shld=SHLD_MAX;
run.score=0;
 info.screen=on;
 info.map=on;
 info.menu=on;
 info.time=GetTickCount();
 info.time_pp=GetTickCount();
 info.speed=2;
 endg.count=0;
for(j=0;j<3;j++)
for(i=0;i<KOLZV;i++)
{
 zvx[j][i]=RAND()%NX;
 zvy[j][i]=RAND()%NY;
}

///SOUND LOADING//////////////////////
f=fopen("sound.DAT","r");if(f==NULL)return 1;
t=0;
while(!feof(f))
{
 gets(f,sound_names[t],1000);if(feof(f))break;
 printf("%s\n",sound_names[t]); 
 t++;
}
fclose(f);

/////////Init DD&&DS///////////////////////////////////////////// 
 if(newdd()!=0){printf("DD Err\n");return 1;} 
 if(DSnew()!=0){printf("DS Err\n");} 
  //for(i=0;i<=50;i++)if(sound_names[i][0]!=0)DSload(sound_names[i]);
 if(setmode(GX, GY, GB, 0, 0)!=0){printf("SetMode Err\n");return 1;}    
 if(setpalette(pal)==1)return 1;
 setparam(WX,WY,0,0,WX-1,WY-1,WX*WY,2); 
 setcharvoidcolor(-1);
 initscale(MAX(WX,WY)*10,WX*10,WY*10); 
return 0;
}
/*********************************Инициализация*********************************/

/*********************************Чистка*********************************/
int end(void)
{
 int i;
  lockvb((void **)&vb,&step);waitluch();memset(vb,0,step*ym);	
  if(unlockvb()!=0)return 1;
 if(deldd()!=0)return 1;
  //DSstop_all();
  //DSstop_all_temp();
  //DSdelete_all();
  //DSdelete_all_temp();
 //if(DSdel()!=0)return 1;
 for(i=0;i<kolpics;i++)deleteBMP(&pics[i]);
 delpic(&pic_map);
 delpic(&pic_kar);
 delpic(&pic_fear);
 delpic(&pic_udar);
 delpic(&pic_red_fear);
 deletescale();
delete mins;
delete ast1;
delete ast2;
delete ast3;
delete post;
delete shld;
delete ammo;
delete pixel;
delete fear;
delete red_fear;
 //Sleep(20000);
 return 0;
}
/*********************************Чистка*********************************/

/*********************************Объекты*********************************/
void initast(int i, int nom)
{
AST s;
 s.x=RAND()%MAPX;
 s.y=RAND()%MAPY;
 s.dx=-AST_MAX_SPEED/2+RAND()%AST_MAX_SPEED;
 s.dy=-AST_MAX_SPEED/2+RAND()%AST_MAX_SPEED;
 s.stat=on; 
 s.pic_speed=RZNAK*(RAND()%100)/100.;  
 if(nom==1){s.pic_stat=RAND()%AST1_KOLPIC;ast1[i]=s;}
 if(nom==2){s.pic_stat=RAND()%AST2_KOLPIC;ast2[i]=s;}
 if(nom==3){s.pic_stat=RAND()%AST3_KOLPIC;ast3[i]=s;}
}

void initpost(int i)
{
POST p;
 p.x=RAND()%MAPX;
 p.y=RAND()%MAPY;
 p.stat=on;
 p.pic_stat=RAND()%POST_KOLPIC;
 p.ammopp=POST_MIN_AMMOPP+RAND()%POST_RAND_AMMOPP;
 p.shldpp=POST_MIN_SHLDPP+RAND()%POST_RAND_SHLDPP; 
 p.shld=POST_MIN_SHLD+RAND()%POST_RAND_SHLD;  
 p.count=MINS_MAX_COUNT;
post[i]=p;
}

void initshld(int i)
{
SHLD s;
 s.x=RAND()%MAPX;
 s.y=RAND()%MAPY;
 s.dx=RZNAK*(rand()%SHLD_MAX_SPEED)/5;
 s.dy=RZNAK*(rand()%SHLD_MAX_SPEED)/5;
 s.stat=on; 
 s.shldpp=SHLD_MIN_SHLDPP+RAND()%SHLD_RAND_SHLDPP;
shld[i]=s;
}

void initammo(int i)
{
AMMO a;
 a.x=RAND()%MAPX;
 a.y=RAND()%MAPY;
 a.dx=RZNAK*(rand()%AMMO_MAX_SPEED)/5;
 a.dy=RZNAK*(rand()%AMMO_MAX_SPEED)/5;
 a.stat=on; 
 a.ammopp=AMMO_MIN_AMMOPP+RAND()%AMMO_RAND_AMMOPP;
ammo[i]=a;
}

void initpixel(int i)
{
PIXEL pi;
 pi.x=(int)save_run_x;//(int)run.x;
 pi.y=(int)save_run_y;//(int)run.y;
 pi.dx=(int)(-COS(run.grad)*PIXEL_SPEEDX)+RZNAK*rand()%PIXEL_SPEEDX/2;
 pi.dy=(int)(-SIN(run.grad)*PIXEL_SPEEDY)+RZNAK*rand()%PIXEL_SPEEDY/2;
 pi.stat=on; 
 pi.count=PIXEL_MAX_COUNT;  
 pixel[i]=pi;
}

void initfear(int i)
{
FEAR f;
 f.x=save_run_x;//(int)run.x;
 f.y=save_run_y;//(int)run.y;
 f.dx=(run.dx+COS(run.grad)*FEAR_SPEEDX);
 f.dy=(run.dy+SIN(run.grad)*FEAR_SPEEDY);
 f.stat=on; 
 f.count=FEAR_MAX_COUNT; 
 fear[i]=f;
}

void initred_fear(int x, int y, int dx, int dy, int max_count)
{
RED_FEAR rf;
 rf.x=x;
 rf.y=y;
 rf.dx=dx;
 rf.dy=dy;
 rf.stat=on; 
 rf.max_count=max_count; 
 rf.count=max_count; 
 rf.xscale=rand()%200/100.; 
 red_fear[red_fear_count]=rf;
 red_fear_count++;if(red_fear_count>=KOL_RED_FEAR)red_fear_count=0;
}

void initmins(int i)
{
MINS m;
if(i<KOL_MINS)
{
 if(i<KOL_POST)
 {
  m.x=post[i].x;
  m.y=post[i].y;
  m.dx=0;
  m.dy=0;
  m.sleju=of;
  m.stat=on;
  m.pic_stat=RAND()%MINS_KOLPIC; 
  m.shld=MINS_MIN_SHLD+RAND()%MINS_RAND_SHLD; 
  m.shldmm=MINS_MIN_SHLDMM+RAND()%MINS_RAND_SHLDMM;
  post[i].count=0;
 }
  else
 {
  m.x=RAND()%MAPX;
  m.y=RAND()%MAPY;
  m.dx=RZNAK*(rand()%MINS_MAX_SPEED)/5;
  m.dy=RZNAK*(rand()%MINS_MAX_SPEED)/5;
  m.sleju=of;
  m.stat=on;
  m.pic_stat=RAND()%MINS_KOLPIC; 
  m.shld=MINS_MIN_SHLD+RAND()%MINS_RAND_SHLD; 
  m.shldmm=MINS_MIN_SHLDMM+RAND()%MINS_RAND_SHLDMM;
 }
mins[i]=m;
}
}

void delpic(PIC *pic)
{
for(int i=0;i<pic->kol;i++) 
{
 if(pic->buffer[i]!=NULL)delete pic->buffer[i];
}
memset(pic,0,sizeof(pic));
}
/*********************************Объекты*********************************/
/*************************************************************************/
/*********************************Конец***********************************/

V3D.cpp

#include "param.h"
#include "defs.h"
 #include "vmemedit.h"
 #include "vdouble.h"
 #include "v3d.h"
 #include "vfiles.h"

#define NULL 0

 int *TAB=NULL ;
 int *TABX=NULL;
 int *TABY=NULL;

/*******************************     1.4*******************************/
/***************************************************************************/
/*******************                   *******************/

int initscale(int xy, int x, int y)
{
 SCALExy=xy;
 SCALEx=x;
 SCALEy=y;
  deletescale();
 TAB=new int[SCALExy];
 TABX=new int[SCALEx];
 TABY=new int[SCALEy];
 if(TAB==NULL || TABX==NULL || TABY==NULL){deletescale();return 1;}
 return 0;
};

void deletescale(void)
{
 if(TAB!=NULL){delete TAB;TAB=NULL;}
 if(TABX!=NULL){delete TABX;TABX=NULL;}
 if(TABY!=NULL){delete TABY;TABY=NULL;} 
};

int scale(uchar *buffer1, int x1, int y1, int x2, int y2, uchar *buffer2, int xk1, int yk1, double ns)
{
int xk2,yk2;
int t1,t2,s;
int nretry,retry,cvet,npix,max,maxx,maxy;
long off1=0,off2=0,xset=0;
  if(TAB==NULL)if(initscale(SCALExy,SCALEx,SCALEy)!=0)return 1;
  //if(ns>=100.)return 0;
 if(x1<xmink1){x1+=xmink1-x1;}
 if(y1<ymink1){y1+=ymink1-y1;}
 if(x2>xmaxk1){x2-=x2-xmaxk1;}
 if(y2>ymaxk1){y2-=y2-ymaxk1;}
xk2=(int)(xk1+ns*(x2-x1+1));
yk2=(int)(yk1+ns*(y2-y1+1));
 if(xk2<xmink2 || yk2<ymink2 || xk1>xmaxk2 || yk1>ymaxk2)return 0;
 if(x2<xmink1  || y2<ymink1  || x1>xmaxk1  || y1>ymaxk1 )return 0;
 if(x1>x2      || y1>y2      || xk1>xk2    || yk1>yk2)   return 0;
 if(xk1<xmink2){s=(int)((xmink2-xk1)/ns)+1;x1+=s;xk1+=(int)(s*ns);}
 if(yk1<ymink2){s=(int)((ymink2-yk1)/ns)+1;y1+=s;yk1+=(int)(s*ns);}
 if(xk2>xmaxk2+1){s=(int)((xk2-xmaxk2-1)/ns);x2-=s+1;xk2-=(int)(s*ns)+1;}
 if(yk2>ymaxk2+1){s=(int)((yk2-ymaxk2-1)/ns);y2-=s+1;yk2-=(int)(s*ns)+1;}
  off1=x321(((long)y1))+x1;
  off2=x322(((long)yk1))+xk1;
if(ns<=1.)
{
  maxx=xk2-xk1+1;maxx--;
  maxy=yk2-yk1+1;maxy--;
  max=MAX(xk2-xk1+1,yk2-yk1+1);
  if(max>SCALExy)return 1;
 for(t1=0;t1<max;t1++)TAB[t1]=(uint)((t1+1)/ns-(uint)(t1/ns));
 for(t1=0;t1<maxy;t1++)
 {
  for(t2=0;t2<maxx;t2++)
  {
   cvet=buffer1[off1+xset];
   if(cvet!=cNUL)buffer2[off2+t2]=(uchar)cvet;
   xset+=TAB[t2];
  }
  off1+=x321((long)TAB[t1]);
  off2+=xm2;
  xset=0;
 }
}

 else

{
  maxx=x2-x1+1;
  maxy=y2-y1+1;
  max=MAX(x2-x1+1,y2-y1+1);
  if(max>SCALExy)return 1;
 for(t1=0;t1<max;t1++)TAB[t1]=(uint)((t1+1)*ns-(uint)(t1*ns));
 for(t1=0;t1<maxy;t1++)
 {nretry=TAB[t1];
  for(retry=0;retry<nretry;retry++)
  {xset=x322((long)retry);
   for(t2=0;t2<maxx;t2++)
   {
    cvet=buffer1[off1+t2];
    npix=TAB[t2];
    if(cvet!=cNUL)memclear8(&buffer2[off2+xset],(uchar)cvet,npix);
    xset+=npix;
   }
  }
   off1+=xm1;
   off2+=x322((long)nretry);
 }
}
return 0;
};

int scaleXY(uchar *buffer1, int x1, int y1, int x2, int y2, uchar *buffer2, int xt, int yt, double nx, double ny)
{
 return scaleKV(buffer1, x1, y1, x2, y2, buffer2, xt, yt, (int)(xt+nx*(x2-x1)), (int)(yt+ny*(y2-y1)));
};

int scaleKV(uchar *buffer1, int x1, int y1, int x2, int y2, uchar *buffer2, int xk1, int yk1, int xk2, int yk2)
{
int t1,t2,s;
int nretry,retry,cvet,npix,maxx,maxy;
long off1=0,off2=0,xset=0;
double nx,ny;
  if(TABX==NULL || TABY==NULL)if(initscale(SCALExy,SCALEx,SCALEy)==-1)return 1;
 if(x1<xmink1){x1+=xmink1-x1;}
 if(y1<ymink1){y1+=ymink1-y1;}
 if(x2>xmaxk1){x2-=x2-xmaxk1;}
 if(y2>ymaxk1){y2-=y2-ymaxk1;}
 if(xk2<xmink2 || yk2<ymink2 || xk1>xmaxk2 || yk1>ymaxk2)return 0;
 if(x2<xmink1  || y2<ymink1  || x1>xmaxk1  || y1>ymaxk1 )return 0;
 if(x1>x2      || y1>y2      || xk1>xk2    || yk1>yk2)   return 0;
nx=(double)((xk2-xk1+1.)/(x2-x1+1.));
ny=(double)((yk2-yk1+1.)/(y2-y1+1.));
 if(xk1<xmink2){s=(int)((xmink2-xk1)/nx)+1;x1+=s;xk1+=(int)(s*nx);}
 if(yk1<ymink2){s=(int)((ymink2-yk1)/ny)+1;y1+=s;yk1+=(int)(s*ny);}
 if(xk2>xmaxk2+1){s=(int)((xk2-xmaxk2-1)/nx);x2-=s+1;xk2-=(int)(s*nx)+1;}
 if(yk2>ymaxk2+1){s=(int)((yk2-ymaxk2-1)/ny);y2-=s+1;yk2-=(int)(s*ny)+1;}
  maxx=x2-x1+1;if(maxx>SCALEx)return 1;
  maxy=y2-y1+1;if(maxy>SCALEy)return 1;
  off1=x321(((long)y1))+x1;
  off2=x322(((long)yk1))+xk1;
 for(t1=0;t1<maxx;t1++)TABX[t1]=(uint)((t1+1)*nx-(uint)(t1*nx));
 for(t1=0;t1<maxy;t1++)TABY[t1]=(uint)((t1+1)*ny-(uint)(t1*ny));
 for(t1=0;t1<maxy;t1++)
 {nretry=TABY[t1];
  for(retry=0;retry<nretry;retry++)
  {xset=x322((long)retry);
   for(t2=0;t2<maxx;t2++)
   {
    cvet=buffer1[off1+t2];
    npix=TABX[t2];
    if(cvet!=cNUL)memclear8(&buffer2[off2+xset],(uchar)cvet,npix);
    xset+=npix;
   }
  }
   off1+=xm1;
   off2+=x322((long)nretry);
 }
return 0;
};

/*********************************    *********************************/

VDOUBLE.CPP

#include "param.h"
#include "defs.h"
 #include "vmemedit.h"
 #include "vdouble.h"
 #include "v3d.h"
 #include "vfiles.h"

/*******************************     1.3*******************************/
/***************************************************************************/
/*******************                   *******************/

void structCparam(PRM *params, int nom)
{
if(nom==0)
{
 xm    = params->xm;
 ym    = params->ym;
 xmink = params->xmink;
 ymink = params->ymink;
 xmaxk = params->xmaxk;
 ymaxk = params->ymaxk;
 xym   = params->xym;
}
if(nom==1)
{
 xm1    = params->xm;
 ym1    = params->ym;
 xmink1 = params->xmink;
 ymink1 = params->ymink;
 xmaxk1 = params->xmaxk;
 ymaxk1 = params->ymaxk;
 xym1   = params->xym;
}
if(nom==2)
{
 xm2    = params->xm;
 ym2    = params->ym;
 xmink2 = params->xmink;
 ymink2 = params->ymink;
 xmaxk2 = params->xmaxk;
 ymaxk2 = params->ymaxk;
 xym2   = params->xym;
}
};

void paramCstruct(int nom, PRM *params)
{
if(nom==0)
{
 params->xm    = xm;
 params->ym    = ym;
 params->xmink = xmink;
 params->ymink = ymink;
 params->xmaxk = xmaxk;
 params->ymaxk = ymaxk;
 params->xym   = xym;
}
if(nom==1)
{
 params->xm    = xm1;
 params->ym    = ym1;
 params->xmink = xmink1;
 params->ymink = ymink1;
 params->xmaxk = xmaxk1;
 params->ymaxk = ymaxk1;
 params->xym   = xym1;
}
if(nom==2)
{
 params->xm    = xm2;
 params->ym    = ym2;
 params->xmink = xmink2;
 params->ymink = ymink2;
 params->xmaxk = xmaxk2;
 params->ymaxk = ymaxk2;
 params->xym   = xym2;
}
};

void setparam(int xm, int ym, int xmink, int ymink, int xmaxk, int ymaxk, long xym, int nom)
{
if(nom==0)
{
 ::xm=xm;
 ::ym=ym;
 ::xmink=xmink;
 ::ymink=ymink;
 ::xmaxk=xmaxk;
 ::ymaxk=ymaxk;
 ::xym=xym;
}
if(nom==1)
{
 ::xm1=xm;
 ::ym1=ym;
 ::xmink1=xmink;
 ::ymink1=ymink;
 ::xmaxk1=xmaxk;
 ::ymaxk1=ymaxk;
 ::xym1=xym;
}
if(nom==2)
{
 ::xm2=xm;
 ::ym2=ym;
 ::xmink2=xmink;
 ::ymink2=ymink;
 ::xmaxk2=xmaxk;
 ::ymaxk2=ymaxk;
 ::xym2=xym;
}
}

void setvoidcolor(int cNUL)
{
 ::cNUL=cNUL;
}

void setbitcolor(int cbit)
{
 ::cbit=cbit;
}

void clearB(uchar *buffer, uchar cvet)
{
 memclear(buffer, cvet, xym);
};

void putB(uchar *buffer1, int x1, int y1, int x2, int y2, uchar *buffer2, int xt, int yt)
{
int t1,mem;
long off1,off2;
 if(x1>xmaxk1 || y1>ymaxk1 || x2<xmink1 || y2<ymink1)goto ENDputB;
 if(x1<xmink1){x1=xmink1;}
 if(y1<ymink1){y1=ymink1;}
 if(x2>xmaxk1){x2=xmaxk1;}
 if(y2>ymaxk1){y2=ymaxk1;}
if(xt>xmaxk2 || yt>ymaxk2 || xt+x2-x1<xmink2 || yt+y2-y1<ymink2)goto ENDputB;
if(xt<xmink2){x1+=xmink2-xt;xt+=xmink2-xt;}
if(yt<ymink2){y1+=ymink2-yt;yt+=ymink2-yt;}
if(xt+x2-x1>xmaxk2){x2-=xt+x2-x1-xmaxk2;}
if(yt+y2-y1>ymaxk2){y2-=yt+y2-y1-ymaxk2;}
 mem=x2-x1+1;
 off1=x321((long)y1)+x1;
 off2=x322((long)yt)+xt;
for(t1=y1; t1<=y2; t1++)
{
 memcopy(&buffer1[off1],&buffer2[off2],mem);
 off1+=xm1;
 off2+=xm2;
}ENDputB:;
};

void putP(uchar *buffer1, int x1, int y1, int x2, int y2, uchar *buffer2, int xt, int yt)
{
int t1,t2;
int mem;
uchar ct;
long off1,off2;
 if(x1>xmaxk1 || y1>ymaxk1 || x2<xmink1 || y2<ymink1)goto ENDputP;
 if(x1<xmink1){x1=xmink1;}
 if(y1<ymink1){y1=ymink1;}
 if(x2>xmaxk1){x2=xmaxk1;}
 if(y2>ymaxk1){y2=ymaxk1;}
if(xt>xmaxk2 || yt>ymaxk2 || xt+x2-x1<xmink2 || yt+y2-y1<ymink2)goto ENDputP;
if(xt<xmink2){x1+=xmink2-xt;xt+=xmink2-xt;}
if(yt<ymink2){y1+=ymink2-yt;yt+=ymink2-yt;}
if(xt+x2-x1>xmaxk2){x2-=xt+x2-x1-xmaxk2;}
if(yt+y2-y1>ymaxk2){y2-=yt+y2-y1-ymaxk2;}
 mem=x2-x1+1;
 off1=x321((long)y1)+x1;
 off2=x322((long)yt)+xt;
for(t1=y1; t1<=y2; t1++)
{
 for(t2=0; t2<mem; t2++)
 {
  ct=buffer1[t2+off1];
  if(ct!=cNUL)buffer2[t2+off2]=ct;
 }
 off1+=xm1;
 off2+=xm2;
}ENDputP:;
};

uchar pointB(int xt, int yt, uchar *buffer)
{
 if(xt>=xmink1 && xt<=xmaxk1 && yt>=ymink1 && yt<=ymaxk1)
 return buffer[x321((long)yt)+xt];
 else return 0;
};

void psetB(int xt, int yt, uchar ct, uchar *buffer)
{
 if(xt>=xmink2 && xt<=xmaxk2 && yt>=ymink2 && yt<=ymaxk2)
 buffer[x322((long)yt)+xt]=ct;
};

void lineB(long x1, long y1, long x2, long y2, uchar ct, uchar *buffer)
{
float xf,yf,xd,yd;
long gorx,gory;
long t12,t1;
gorx=x2-x1;
gory=y2-y1;
if(ABS(gorx) < ABS(gory))
{
 if(gory!=0)
 {
 if(gory<0){yd=-1;}else{yd=1;}
 xd = (float)gorx/ABS(gory);
 }
 t12 = ABS(gory);
}
else
{
 if(gorx!=0)
 {
 if(gorx<0){xd=-1;}else{xd=1;}
 yd = (float)gory/ABS(gorx);
 }
 t12 = ABS(gorx);
}
 xf = (float)x1;
 yf = (float)y1;
for (t1 = 0; t1 < t12; t1++)
{
 *(buffer+(uint)xf+x322((ulong)yf))=ct;
 xf += xd;
 yf += yd;
}
 ((uchar *)(buffer))[x2+x322((long)y2)]=ct;
};/* NO */

void kvadratB(int x1, int y1, int x2, int y2, uchar ct, uchar *buffer)
{
 long t1,t2;
 long mem;
if(x1>xmaxk2 || y1>ymaxk2 || x2<xmink2 || y2<ymink2)goto ENDkvadratB;
if(x1<xmink2){x1=xmink2;}
if(y1<ymink2){y1=ymink2;}
if(x2>xmaxk2){x2=xmaxk2;}
if(y2>ymaxk2){y2=ymaxk2;}
 mem=x2-x1+1;
 t2=x1+x322((long)y1);
for(t1=y1;t1<=y2;t1++)
{
 memclear(&buffer[t2],ct,mem);t2+=xm2;
}
ENDkvadratB:;
};

void setcharvoidcolor(int charNUL)
{
 ::charNUL=charNUL;
}

void bukvaG(int xc, int yc, uchar cvet, uchar ct, uchar *buffer)
{
long offset;
long xt,yt;
uchar *work_char;
uchar bit_mask = 0x80;
if(xc>xmaxk2 || yc>ymaxk2 || xc+7<xmink2 || yc+7<ymink2)goto ENDbukvaG;
work_char=char8x8+ct*8;
offset=x322((long)yc)+xc;
if(charNUL==0)
for(yt=0;yt<8;yt++)
{
 bit_mask = 0x80;
 for (xt=0;xt<8;xt++)
 {
  if(((*work_char&bit_mask)!=0))
  buffer[offset+xt]=cvet;
  bit_mask = (uchar)(bit_mask>>1);
 }
 offset+=xm2;
 work_char++;
}
 else
for(yt=0;yt<8;yt++)
{
 bit_mask = 0x80;
 for (xt=0;xt<8;xt++)
 {  
  buffer[offset+xt]=((*work_char&bit_mask)!=0)*cvet;
  bit_mask = (uchar)(bit_mask>>1);
 }
 offset+=xm2;
 work_char++;
}
ENDbukvaG:;
};

void printG(int xt, int yt, uchar ct, char *namet, uchar *buffer)
{
uint t1;
uchar *name;
name=(uchar *)namet;
for(t1=0; name[t1]!=0; t1++)
{
 bukvaG(xt+(t1<<3),yt,ct,name[t1],buffer);
}
};

void printGulong(int xt, int yt, uchar ct, ulong dl, uchar *buffer)
{
ulong t1,t2,t3;
uchar namecod[11],bait; t1=dl; t3=0;
for(t2=0;t2<=9;t2++)
{
 bait=(uchar)(t1-(ulong)(t1/10)*10+48);
 t1=(ulong)(t1/10);
 if(t1==0 && bait==48){t3=10-t2;break;}
 namecod[(uint)(9-t2)]=bait;
}
namecod[10]=0;
if(dl==0){dl=48;printG(xt,yt,ct,(char *)(&dl), buffer);}
printG(xt,yt,ct,(char *)(&namecod[(uint)t3]), buffer);
};

void lineg(int yt, int x1, int x2, uchar ct, uchar *buffer)
{
if(x1>xmaxk2 || x2<xmink2 || yt>ymaxk2 || yt<ymink2)goto ENDlineg;
if(x1<xmink2){x1=xmink2;}
if(x2>xmaxk2){x2=xmaxk2;}
 memclear(buffer+x322((long)yt)+x1,ct,x2-x1+1);
ENDlineg:;
};

void linev(int xt, int y1, int y2, uchar ct, uchar *buffer)
{
 int t1;
 long offset=0;
if(y1>ymaxk2 || y2<ymink2 || xt>xmaxk2 || xt<xmink2)goto ENDlinev;
if(y1<ymink2){y1=ymink2;}
if(y2>ymaxk2){y2=ymaxk2;}
 offset+=x322((long)(y1-1))+xt;
for(t1=y1;t1<=y2;t1++)
{
 offset+=xm2;
 buffer[offset]=ct;
}
ENDlinev:;
};

void pal864(RGB *cpal)
{
 uchar G,R,B,cvet;
 RGB color;
 pali1=(const uchar)64;pali2=(const uchar)255;Rm=(const uchar)6;Gm=(const uchar)8;Bm=(const uchar)4;
for(cvet=3;cvet<64;cvet+=4)
{
 color.red=cvet; color.green=cvet; color.blue=cvet; cpal[(cvet-3)/4   ]=color;
 color.red=cvet; color.green=0   ; color.blue=0   ; cpal[(cvet-3)/4+16]=color;
 color.red=0   ; color.green=cvet; color.blue=0   ; cpal[(cvet-3)/4+32]=color;
 color.red=0   ; color.green=0   ; color.blue=cvet; cpal[(cvet-3)/4+48]=color;
}cvet=64;
for(R=13;R<64;R+=10)
{color.red=R;
for(G=7;G<64;G+=8)
{color.green=G;
for(B=15;B<64;B+=16)
{color.blue=B;
cpal[cvet]=color;cvet++;
}
}
}
};

void pal666(RGB *cpal)
{
uchar G,R,B,cvet;
RGB color;
pali1=(const uchar)0;pali2=(const uchar)255;Rm=(const uchar)6;Gm=(const uchar)6;Bm=(const uchar)6;
color.red=0;color.green=0;color.blue=0;
for(cvet=0;cvet<40;cvet++)
{
 cpal[cvet+216]=color;
}cvet=0;
for(R=0;R<6;R++)
{color.red=(uchar)(R*10+13);
for(G=0;G<6;G++)
{color.green=G*10+13;
for(B=0;B<6;B++)
{color.blue=B*10+13;
cpal[R*36+G*6+B]=color;//cvet++;
}
}
}
};

void pal64x4(RGB *cpal)
{
uchar cvet;
RGB color;
pali1=(const uchar)0;pali2=(const uchar)255;Rm=(const uchar)0;Gm=(const uchar)0;Bm=(const uchar)0;
for(cvet=0;cvet<64;cvet++)
{
 color.red=cvet; color.green=cvet; color.blue=cvet; cpal[cvet    ]=color;
 color.red=cvet; color.green=0   ; color.blue=0   ; cpal[cvet+64 ]=color;
 color.red=0   ; color.green=cvet; color.blue=0   ; cpal[cvet+128]=color;
 color.red=0   ; color.green=0   ; color.blue=cvet; cpal[cvet+192]=color;
}
};

void pal444(RGB *cpal)
{
uchar c,cr,cg,cb;
RGB color;
pali1=(const uchar)0;pali2=(const uchar)255;Rm=(const uchar)4;Gm=(const uchar)4;Bm=(const uchar)4;
for(c=1;c<=4;c++)
{
for(cr=1;cr<=4;cr++)
{color.red=cr*4-1+(c-1)*16;
for(cg=1;cg<=4;cg++)
{color.green=cg*4-1+(c-1)*16;
for(cb=1;cb<=4;cb++)
{color.blue=cb*4-1+(c-1)*16;
 cpal[(c-1)*64+(cr-1)*16+(cg-1)*4+(cb-1)]=color;
}
}
}
}
};

/*********************************    *********************************/

VMEMEDIT.CPP

#include "param.h"
#include "defs.h"
 #include "vmemedit.h"
 #include "vdouble.h"
 #include "v3d.h"
 #include "vfiles.h"

/*******************************     1.2*******************************/
/***************************************************************************/
/********************************     ********************************/

void memcopy(uchar *buffer1, uchar *buffer2, ulong mem)
{
 ulong t,x16=32768L;
if(mem<x16)
{
 memcopy32(buffer1,buffer2,mem);
}
 else
{
 memcopy32(buffer1,buffer2,mem%x16);
 for(t=mem%x16;t<mem;t+=x16)
 {
  if(t+x16>mem){break;}
  memcopy32(&buffer1[t],&buffer2[t],x16);
 }
}
};

void memcopy32(uchar *buffer1, uchar *buffer2, ulong mem)
{
memcopy8(buffer1+mem-mem%4, buffer2+mem-mem%4, mem%4);
mem=mem>>2;
asm push ds
asm mov edi, buffer2
asm mov esi, buffer1
asm mov ecx, mem
asm cld
asm rep movsd
asm pop ds
};

void memcopy16(uchar *buffer1, uchar *buffer2, ulong mem)
{
memcopy8(buffer1+mem-mem%2, buffer2+mem-mem%2, mem%2);
mem=mem>>1;
asm push ds
asm mov edi, buffer2
asm mov esi, buffer1
asm mov ecx, mem
asm cld
asm rep movsw
asm pop ds
};

void memcopy8(uchar *buffer1, uchar *buffer2, ulong mem)
{
asm push ds
asm mov edi, buffer2
asm mov esi, buffer1
asm mov ecx, mem
asm cld
asm rep movsb
asm pop ds
};

void memclear(uchar *buffer, uchar cvet, ulong mem)
{
 ulong t,x16=32768L;
if(mem<=x16)
{
 memclear32(buffer,cvet,mem);
}
 else
{
 memclear32(buffer,cvet,mem%x16);
 for(t=mem%x16;t<mem;t+=x16)
 {
  if(t+x16>mem){break;}
  memclear32(&buffer[t],cvet,x16);
 }
}
};

void memclear32(uchar *buffer, uchar cvet, ulong mem)
{
memclear8(buffer+mem-mem%4, cvet, mem%4);
mem=mem>>2;
asm mov eax, buffer
asm mov edi, eax
asm mov ecx, mem
asm  mov al, cvet
asm  mov ah, al
asm   sal eax, 16
asm  mov al, cvet
asm  mov ah, al
asm rep stosd
};

void memclear16(uchar *buffer, uchar cvet, ulong mem)
{
memclear8(buffer+mem-mem%2, cvet, mem%2);
mem=mem>>1;
asm mov eax, buffer
asm mov edi, eax
asm mov ecx, mem
asm  mov al, cvet
asm  mov ah, al
asm   sal eax, 16
asm  mov al, cvet
asm  mov ah, al
asm rep stosw
};

void memclear8(uchar *buffer, uchar cvet, ulong mem)
{
asm mov eax, buffer
asm mov edi, eax
asm mov ecx, mem
asm  mov al, cvet
asm  mov ah, al
asm   sal eax, 16
asm  mov al, cvet
asm  mov ah, al
asm rep stosb
};

/*********************************    *********************************/

тут изи видно что другой автор по психологии названий переменных

жаль что на qBasic мои проги в другом городе на 386-м компе

особенно был горд процедурой масштабированая картинке которая на 386-м довольно быстро работала

256 цветов офк

E1azor · 1 мая 2020

@hira88

почему ты ещё не в кремниевой долине?

Rooster · 1 мая 2020

Силиконовая

**PeaceHaver** · 1 мая 2020

E1azor написал 12 часов назад:

PeaceHaver написал 23 часа назад:

скетчапа, потом блендер, в дальнейшем, видимо, компас/солид

Ну это совсем хуйня, сам справишься (строил геометрию скриптами на питоне в spaceclame, но там есть небольшой рачёк параметризации если строить мышкотыкательно, хз, и скрипты по кд падают(если не перезайти ), хуйня ебаная короче, может быть это из-за ансиса в котором всё через жопу)

Интересно было бы узнать от тебя общие выводы (когда появятся) по разным прогам, чтобы знать норм или хуйня.

Я смотрел рейтинги более 20 прог именно для 3д принтеров, там строго блендер, потом скетчап и дальше вся остальная хуйня. Но я понимаю, что для промышленных вещей нужен Компас / солид / авто.

Автокад и 3дсмакс осваивал ещё в студенчестве самостоятельно - вроде не умер. Но, думал, мб пообщаться с кем есть об этом.

hira88 · 2 мая 2020

E1azor написал 01.05.2020 в 16:18:

почему ты ещё не в кремниевой долине?

Скрытый текст

Изменено 2 мая 2020 пользователем hira88

madvlaydin · 2 мая 2020

хира у тебя денег нет в Россию из Крыма переехать?

Rintz · 2 мая 2020

как же сложно включить прокси в браузере, ебануться можно, или все прокси тоже забанены?)

Just.Doit · 2 мая 2020

Rintz написал 35 минут назад:

как же сложно включить прокси в браузере, ебануться можно, или все прокси тоже забанены?)

frigate работает без нареканий

JuJeu · 2 мая 2020

начал учить React :shitpalm:

GoldRobot · 2 мая 2020

:zemlyapuhom:

JuJeu · 2 мая 2020

хуле поделать. Они или фулстэк с реактом хотят или чтобы на джаве лабал. Других вакансий похоже просто не существует.

FeelYourDestiny · 2 мая 2020

А что со стартапчиком?

JuJeu · 2 мая 2020

Хочу обратно в СФ :pepehands:

PochtiKakLoda · 2 мая 2020

JuJeu написал 1 час назад:

хуле поделать. Они или фулстэк с реактом хотят или чтобы на джаве лабал. Других вакансий похоже просто не существует.

так ты же был фронтом вроде на жс? или ты бек

у нас для беков самый стандарт это C# ASP.NET Core back + vue.js / angular.js фронт

Index · 2 мая 2020

Эх поучить бы ангулярчик да диплом писать надо.

JuJeu · 2 мая 2020

PochtiKakLoda написал 11 минут назад:

JuJeu написал 1 час назад:

хуле поделать. Они или фулстэк с реактом хотят или чтобы на джаве лабал. Других вакансий похоже просто не существует.

так ты же был фронтом вроде на жс? или ты бек

у нас для беков самый стандарт это C# ASP.NET Core back + vue.js / angular.js фронт

У меня было 50/50, а потом стало 10/90 (в сторону бэка).

Си шарп я точно не буду делать.

Я хз, в тот же амазон джаву хотят, хотя там мб и можно на Шарпе, но спасибо.

Но я как понимаю, они там пишут (рекрутеры) java/sharp/c++ только с той точки зрения, что они хотят OOP, но как блять рекрутерам объяснить, что ооп можно знать без этих языков, ну там гиблое дело, если эти челики думают, что 3 года работы = 1 году обучения в шараге. Я просто сам лично видел выпускников этих топовых школ, им до джуна ещё шагать и шагать.

DDamager · 2 мая 2020

JuJeu написал 3 часа назад:

Хочу обратно в СФ

а ты что переехал куда-то?

JuJeu · 2 мая 2020

DDamager написал Только что:

JuJeu написал 3 часа назад:

Хочу обратно в СФ

а ты что переехал куда-то?

в Ла почти два года.

Войти

Сейчас на странице Всего пользователей: 4 (0 пользователей, 4 гостя)

Программирование[9]

Перепись 260 пользователей проголосовало

Рекомендованные сообщения

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Поделиться сообщением

Ссылка на сообщение

Перепись
260 пользователей проголосовало