예제 #1
0
파일: nupac.cpp 프로젝트: laulandne/src
void DoTunnel(struct Player *p, int w)
{
  p->dir=DIR_STOP;  p->nextdir=DIR_STOP;
  p->mcnt=0;  p->mc=0;
  DrawBoardPart(p->lx,p->ly,ReadBoard(p->lx,p->ly));
  DrawBoardPart(p->bx,p->by,ReadBoard(p->bx,p->by));
  switch(w) {
    case LEFT_TUNNEL:
      p->zx=17*BITMAP_X;  p->zy=5*BITMAP_Y;  p->lx=17;  p->ly=5;  break;
    case RIGHT_TUNNEL:
      p->zx=1*BITMAP_X;  p->zy=5*BITMAP_Y;  p->lx=1;  p->ly=5;  break;
    default: debug_msg((char *)"ILLEGAL tunnel!\n"); break;
  }
}
예제 #2
0
파일: nupac.cpp 프로젝트: laulandne/src
void DrawScreen(void)
{
  int x,y,c;
  /* debug_msg((char *)"DEBUG- DrawScreen\n"); */
  destw->setForeground(0xffffff);  destw->setBackground(0);
  destw->clear();
  NumDots=0;
  for(y=0;y<BoardY;y++) {
    for(x=0;x<BoardX;x++) {
      c=ReadBoard(x,y);  DrawBoardPart(x,y,c);
      if(c==(int)'.') NumDots++;
      if(c==(int)'*') NumDots++;
    }
  }
  UpdateScore();
}
예제 #3
0
			void ReadChunks()
			{
				Context context;

				while (!stream.Eof())
				{
					dword id = stream.Read32();
					const dword length = stream.Read32();
					NST_VERIFY( length <= SIZE_1K * 4096UL );

					switch (id)
					{
						case AsciiId<'N','A','M','E'>::V: id = (context( 0, id ) ? ReadName       (         ) : 0); break;
						case AsciiId<'R','E','A','D'>::V: id = (context( 1, id ) ? ReadComment    (         ) : 0); break;
						case AsciiId<'D','I','N','F'>::V: id = (context( 2, id ) ? ReadDumper     (         ) : 0); break;
						case AsciiId<'T','V','C','I'>::V: id = (context( 3, id ) ? ReadSystem     ( context ) : 0); break;
						case AsciiId<'B','A','T','R'>::V: id = (context( 4, id ) ? ReadBattery    (         ) : 0); break;
						case AsciiId<'M','A','P','R'>::V: id = (context( 5, id ) ? ReadBoard      (         ) : 0); break;
						case AsciiId<'M','I','R','R'>::V: id = (context( 6, id ) ? ReadMirroring  (         ) : 0); break;
						case AsciiId<'C','T','R','L'>::V: id = (context( 7, id ) ? ReadController (         ) : 0); break;
						case AsciiId<'V','R','O','R'>::V: id = (context( 8, id ) ? ReadChrRam     (         ) : 0); break;

						default: switch (id & 0x00FFFFFF)
						{
							case AsciiId<'P','C','K'>::V:
							case AsciiId<'C','C','K'>::V:
							case AsciiId<'P','R','G'>::V:
							case AsciiId<'C','H','R'>::V:
							{
								uint index = id >> 24 & 0xFF;

								if (index >= Ascii<'0'>::V && index <= Ascii<'9'>::V)
								{
									index -= Ascii<'0'>::V;
								}
								else if (index >= Ascii<'A'>::V && index <= Ascii<'F'>::V)
								{
									index = index - Ascii<'A'>::V + 10;
								}
								else
								{
									index = ~0U;
								}

								if (index < 16)
								{
									switch (dword part = (id & 0x00FFFFFF))
									{
										case AsciiId<'P','C','K'>::V:
										case AsciiId<'C','C','K'>::V:

											part = (part == AsciiId<'C','C','K'>::V);
											id = (context( 9 + (part << 4) + index, id) ? ReadChecksum( part, index, context.roms[part][index] ) : 0);
											break;

										case AsciiId<'P','R','G'>::V:
										case AsciiId<'C','H','R'>::V:

											part = (part == AsciiId<'C','H','R'>::V);
											id = (context( 9 + 32 + (part << 4) + index, id ) ? ReadRom( part, index, length, context.roms[part] ) : 0);
											break;
									}

									break;
								}
							}

							default:

								id = ReadUnknown( id );
								break;
						}
					}

					if (id < length)
					{
						for (id = length - id; id > 0x7FFFFFFF; id -= 0x7FFFFFFF)
							stream.Seek( 0x7FFFFFFF );

						if (id)
							stream.Seek( id );
					}
					else if (id > length)
					{
						throw RESULT_ERR_CORRUPT_FILE;
					}
				}

				for (uint i=0; i < 2; ++i)
				{
					uint count = 0;
					dword size = 0;

					for (uint j=0; j < 16; ++j)
					{
						if (const dword n=context.roms[i][j].data.Size())
						{
							count++;
							size += n;
						}
					}

					if (count)
					{
						Profile::Board::Roms& rom = (i ? profile.board.chr : profile.board.prg);
						rom.resize( count );

						Ram& dst = (i ? chr : prg);
						dst.Set( size );

						if (!rom.empty())
						{
							for (Profile::Board::Pins::const_iterator it(rom.front().pins.begin()), end(rom.front().pins.end()); it != end; ++it)
								dst.Pin(it->number) = it->function.c_str();
						}

						size = 0;

						for (uint j=0, k=0; j < 16; ++j)
						{
							const Context::Rom& src = context.roms[i][j];

							if (src.data.Size())
							{
								rom[k].id = k;
								rom[k].size = src.data.Size();
								rom[k].hash.Assign( NULL, src.crc );
								k++;

								std::memcpy( dst.Mem(size), src.data.Mem(), src.data.Size() );
								size += src.data.Size();
							}
						}
					}
				}

				if (profileEx.nmt == ProfileEx::NMT_HORIZONTAL)
				{
					profile.board.solderPads = Profile::Board::SOLDERPAD_V;
				}
				else if (profileEx.nmt == ProfileEx::NMT_HORIZONTAL)
				{
					profile.board.solderPads = Profile::Board::SOLDERPAD_H;
				}

				switch (context.system)
				{
					case Context::SYSTEM_NTSC:

						if (favoredSystem == FAVORED_FAMICOM)
						{
							profile.system.type = Profile::System::FAMICOM;
						}
						if (favoredSystem == FAVORED_DENDY)
						{
							profile.system.type = Profile::System::DENDY;
							profile.system.cpu = Profile::System::CPU_DENDY;
							profile.system.ppu = Profile::System::PPU_DENDY;
						}
						else
						{
							profile.system.type = Profile::System::NES_NTSC;
						}
						break;

					default:

						profile.multiRegion = true;

						if (favoredSystem == FAVORED_FAMICOM)
						{
							profile.system.type = Profile::System::FAMICOM;
							break;
						}
						else if (favoredSystem != FAVORED_NES_PAL && favoredSystem != FAVORED_DENDY)
						{
							profile.system.type = Profile::System::NES_NTSC;
							break;
						}

					case Context::SYSTEM_PAL:

						if (favoredSystem == FAVORED_DENDY)
						{
							profile.system.type = Profile::System::DENDY;
							profile.system.cpu = Profile::System::CPU_DENDY;
							profile.system.ppu = Profile::System::PPU_DENDY;
						}
						else
						{
							profile.system.type = Profile::System::NES_PAL;
							profile.system.cpu = Profile::System::CPU_RP2A07;
							profile.system.ppu = Profile::System::PPU_RP2C07;
						}
						break;
				}
			}
예제 #4
0
파일: nupac.cpp 프로젝트: laulandne/src
/* NOTE: This function isn't finished yet... */
bool NewCheckSpace(int x, int y, int *dx, int *dy)
{
  int foo;
  foo=ReadBoard(x,y);
  if(foo>'a') { return true; } else { return false; }
}
예제 #5
0
파일: nupac.cpp 프로젝트: laulandne/src
bool CheckSpace(int x, int y, int *dx, int *dy)
{
  int bx,by,foo;
  bx=(x/BITMAP_X)+(*dx);  by=(y/BITMAP_Y)+(*dy);  foo=ReadBoard(bx,by);
  if(foo>='a') { return true; } else { return false; }
}
예제 #6
0
파일: nupac.cpp 프로젝트: laulandne/src
void MovePac(struct Player *P)
{
  int nx,ny,goo=0,dx=0,dy=0,part;
  bool Check=false;
  P->mc++;
  if(WakaFlag) { WakaFlag=0; P->cur=P->old; }
  else {
    WakaFlag=1;  P->old=P->cur;  P->cur=SPR_PACNONE;
    //destw->draw(picts[SPR_PACNONE],P->zx,P->zy);
    destw->copyBlock(srcs,picts[SPR_PACNONE]->x,picts[SPR_PACNONE]->y,P->zx,P->zy,BITMAP_X,BITMAP_Y);
  }
  if(P->mc==P->speed) {
    if((P->bx==0)&&(P->by==5)) { DoTunnel(P,LEFT_TUNNEL); } else
    if((P->bx==18)&&(P->by==5)) { DoTunnel(P,RIGHT_TUNNEL); }
    P->mc=0;
    nx=P->zx;  ny=P->zy;
    if(P->mcnt==CountMax) Check=true;
    if(P->mcnt<0) Check=true;
    if(Check) {
      P->mcnt=0;  P->dir=P->nextdir;
    }
    switch(P->dir) {
      case DIR_UP:    dy= -1; P->cur=SPR_PACUP; break;
      case DIR_DOWN:  dy=1;  P->cur=SPR_PACDOWN; break;
      case DIR_LEFT:  dx= -1; P->cur=SPR_PACLEFT; break;
      case DIR_RIGHT: dx=1;  P->cur=SPR_PACRIGHT; break;
      default: break;
    }
    dx=dx*AspectX;  dy=dy*AspectY;
    //dy=DirY[P->dir];  dx=DirX[P->dir];
    //P->cur=(*shapes)[P->dir];
    if(Check) {
      P->lx=(nx+BITMAP_X/2)/BITMAP_X;  P->ly=(ny+BITMAP_Y/2)/BITMAP_Y;
      part=ReadBoard(P->bx,P->by);
      if((part)==(int)'.') {
        WriteBoard(P->bx,P->by,(int)',');  NumDots--;  NumPoints+=1;
        UpdateScore();
      } else
      if((part)==(int)'*') {
        WriteBoard(P->bx,P->by,(int)',');  NumDots--;  NumPoints+=10;
        UpdateScore();  DoMyBlue();
      }
      /*P->lx=(nx+BITMAP_X/2)/BITMAP_X;  P->ly=(ny+BITMAP_Y/2)/BITMAP_Y;*/
      goo=CheckSpace(nx,ny,&dx,&dy);
      if(goo) {
        P->dir=DIR_STOP;  P->nextdir=DIR_STOP;
      }
    }
    if(!goo) {
      if(FOOBAR_PACMOVE)
        DrawBoardPart(P->lx,P->ly,ReadBoard(P->lx,P->ly));
      nx+=dx;  ny+=dy;
      P->mcnt++;
#ifdef CATCH_OUT
      if(ny<0) { ny=1; P->dir=DIR_DOWN; }
      if(ny>SCREEN_Y+BITMAP_X) { ny=SCREEN_Y-2; P->dir=DIR_UP; }
      if(nx<0) { nx=1; P->dir=DIR_RIGHT; }
      if(nx>SCREEN_X) { nx=SCREEN_X-2; P->dir=DIR_LEFT; }
#endif
      if(WakaFlag) {
        //destw->draw(picts[P->cur],nx,ny);
        destw->copyBlock(srcs,picts[P->cur]->x,picts[P->cur]->y,nx,ny,BITMAP_X,BITMAP_Y);
      }
      else {
        //destw->draw(picts[SPR_PACNONE],nx,ny);
        destw->copyBlock(srcs,picts[SPR_PACNONE]->x,picts[SPR_PACNONE]->y,nx,ny,BITMAP_X,BITMAP_Y);
      }
      P->zx=nx;  P->zy=ny;
      P->bx=(nx+BITMAP_X/2)/BITMAP_X;  P->by=(ny+BITMAP_Y/2)/BITMAP_Y;
    }
  }
}
예제 #7
0
파일: nupac.cpp 프로젝트: laulandne/src
void MoveGhost(struct Player *g)
{
  int nx,ny,goo=0,dx=0,dy=0;
  bool Check=false;
  g->mc++;
  if(g->mc==g->speed) {
    g->mc=0;
    nx=g->zx;  ny=g->zy;
    if(g->mcnt==CountMax) Check=true;
    if(g->mcnt<0) Check=true;
    if(Check) {
      g->mcnt=0;  g->dir=g->nextdir;
    }
    if(g->lastint==G_SMART) {
      switch(g->dir) {
        case DIR_UP:    dy= -1; g->cur=SPR_GUP;    break;
        case DIR_DOWN:  dy=1;   g->cur=SPR_GDOWN;  break;
        case DIR_LEFT:  dx= -1; g->cur=SPR_GLEFT;  break;
        case DIR_RIGHT: dx=1;   g->cur=SPR_GRIGHT; break;
        default: break;
      }
    }
    if(g->lastint==G_SCARED) {
      switch(g->dir) {
        case DIR_UP:    dy= -1; g->cur=SPR_BUP;    break;
        case DIR_DOWN:  dy=1;   g->cur=SPR_BDOWN;  break;
        case DIR_LEFT:  dx= -1; g->cur=SPR_BLEFT;  break;
        case DIR_RIGHT: dx=1;   g->cur=SPR_BRIGHT; break;
        default: break;
      }
    }
    if(g->lastint==G_EYES) {
      switch(g->dir) {
        case DIR_UP:    dy= -1; g->cur=SPR_EUP;    break;
        case DIR_DOWN:  dy=1;   g->cur=SPR_EDOWN;  break;
        case DIR_LEFT:  dx= -1; g->cur=SPR_ELEFT;  break;
        case DIR_RIGHT: dx=1;   g->cur=SPR_ERIGHT; break;
        default: break;
      }
    }
    dx=dx*AspectX;  dy=dy*AspectY;
    if(Check) {
      DrawBoardPart(g->lx,g->ly,ReadBoard(g->lx,g->ly));
      g->lx=(nx+BITMAP_X/2)/BITMAP_X;  g->ly=(ny+BITMAP_Y/2)/BITMAP_Y;
      goo=CheckSpace(nx,ny,&dx,&dy);
      if(goo) {
        GhostChoose(g); g->mcnt=CountMax; MoveGhost(g);
      }
    }
    if(!goo) {
      if(FOOBAR_PACMOVE) DrawBoardPart(g->lx,g->ly,ReadBoard(g->lx,g->ly));
      nx+=dx;  ny+=dy;
      g->mcnt++;
#ifdef CATCH_OUT
      if(ny<0) { ny=1; g->dir=DIR_DOWN; }
      if(ny>SCREEN_Y) { ny=SCREEN_Y-2; g->dir=DIR_UP; }
      if(nx<0) { nx=1; g->dir=DIR_RIGHT; }
      if(nx>SCREEN_X) { nx=SCREEN_X-2; g->dir=DIR_LEFT; }
#endif
      //destw->draw(picts[g->cur],nx,ny);
      destw->copyBlock(srcs,picts[g->cur]->x,picts[g->cur]->y,nx,ny,BITMAP_X,BITMAP_Y);
      g->zx=nx;  g->zy=ny;
      g->bx=(nx+BITMAP_X/2)/BITMAP_X;  g->by=(ny+BITMAP_Y/2)/BITMAP_Y;
      if(g->lastint==G_EYES)
        if((g->bx==HomeX)&&(g->by==HomeY))
          { g->lastint=G_SMART; DoNormal(g); }
    }
  }
}