void getColorBytes(unsigned char* bytes)
{
// 1000 byte color map
unsigned char* bptr = bytes;
for (int yb = 0; yb < yBlocks; yb++)
{
for (int xb = 0; xb < xBlocks; xb++)
{
unsigned char c1 = getBlockColor(xb, yb, 0);
unsigned char c2 = getBlockColor(xb, yb, 1);
unsigned char colorbyte = (c1 << 4) | c2;
*bptr = colorbyte;
bptr++;
}
}
}
static void capture_board(blockColor gameBoard[8][8])
{
int x = 0, y = 0;
/*! attempt to take a snapshot of the window */
HRESULT hRet = pDDSysSurface7->BltFast(0, 0, pDDSurface7, &windowRect, DDBLTFAST_WAIT);
/*! quit if failure */
if(FAILED(hRet)) { return; }
/*! iterate through each row */
for(y=0;y<8;y++)
{
/*! calculate current block Y offset */
int curY = baseY + eachH*y + quarH;
/*! iterate through each column */
for(x=0;x<8;x++)
{
/*! calculate current block X offset */
int curX = baseX + eachW*x + quarW;
/*! calculate current block average RGB */
{
int x2 = 0, y2 = 0;
uint32 accumR = 0;
uint32 accumG = 0;
uint32 accumB = 0;
for(y2=0;y2<halfH;y2++)
{
/*! calculate current pixel Y offset */
int pixelY = curY + y2;
for(x2=0;x2<halfW;x2++)
{
/*! calculate current pixel X offset */
int pixelX = curX + x2;
/*! fetch current pixel value */
uint32 curPixel = rgb32[pixelY*windowWidth+pixelX];
/*! added to each RGB component's accumulator */
accumR += (curPixel & 0x00FF0000) >> 16;
accumG += (curPixel & 0x0000FF00) >> 8;
accumB += (curPixel & 0x000000FF) >> 0;
}
}
/*! calculate each RGB component's average */
uint32 avgR = accumR / (halfW*halfH);
uint32 avgG = accumG / (halfW*halfH);
uint32 avgB = accumB / (halfW*halfH);
/*! calculate average RGB */
uint32 avgRGB = (avgR << 16) | (avgG << 8) | avgB;
/*! retrieve current block color */
blockColor curBlock = getBlockColor((double)avgR / 255.0, (double)avgG / 255.0, (double)avgB / 255.0);
/*! update gameboard */
gameBoard[y][x] = curBlock;
}
}
}
return;
}
void GameController::CoordinateChanged(const QPoint &_coordinate)
{
if(this->pipeManager->currentPipe==0)
return;
QPoint lastcoordinate = this->pipeManager->currentPipe->back();
QColor _coordinateColor = getBlockColor(_coordinate);
STATE _coordinateState = getBlockState(_coordinate);
int distance = Distance(lastcoordinate,_coordinate);
if((_coordinateState&CURRENT)==0&&(getBlockState(lastcoordinate)&ORIGIN)!=0&&getBlockColor(lastcoordinate)==this->pipeManager->currentPipe->Color&&this->pipeManager->currentPipe->size()>1)
return;
if(distance!=1)
{
if(distance<=5&&(_coordinateState&ORIGIN)==0)
AutoSearchPath(_coordinate);
return;
}
if((_coordinateState&WAY)==0)
{
if((_coordinateState&ORIGIN)==0)
{
setBlockState(_coordinate,WAY|CURRENT);
pipeManager->currentPipe->push_back(_coordinate);
emit ForwardPipe();
emit UpdatePipeDisplay();
}
else
{
if(_coordinateColor==pipeManager->currentPipe->Color)
{
setBlockState(_coordinate,WAY|CURRENT);
pipeManager->currentPipe->push_back(_coordinate);
emit CompletePipe(pipeManager->currentPipe);
emit UpdatePipeDisplay();
}
}
}
else
{
if((_coordinateState&CURRENT)!=0)
{
while(pipeManager->currentPipe->back()!=_coordinate)
{
QPoint backpoint = pipeManager->currentPipe->back();
QColor backpointColor = getBlockColor(backpoint);
setBlockState(backpoint,~CURRENT);
if(backpointColor==GameData::BgColor || backpointColor==pipeManager->currentPipe->Color)
setBlockState(backpoint,~WAY);
else
{
setBlockState(backpoint,~BREAK);
Pipe* pipe = pipeManager->getPipe(backpointColor);
bool unable = false;
for(int i=0;i<pipe->size();++i)
{
STATE _state = getBlockState(pipe->at(i));
if((_state&BREAK)!=0)
unable = true;
if(unable && (_state&BREAK)==0)
setBlockState(pipe->at(i),~WAY);
else
setBlockState(pipe->at(i),WAY);
}
}
pipeManager->currentPipe->pop_back();
}
emit BackwardPipe();
emit UpdatePipeDisplay();
}
else
{
if((_coordinateState&ORIGIN)!=0)
return;
Pipe* pipe = pipeManager->getPipe(_coordinateColor);
setBlockState(_coordinate,WAY|CURRENT|BREAK);
pipeManager->currentPipe->push_back(_coordinate);
bool unable = false;
for(int i=0;i<pipe->size();++i)
{
STATE _state = getBlockState(pipe->at(i));
if((_state&BREAK)!=0)
unable = true;
if(unable && (_state&BREAK)==0)
setBlockState(pipe->at(i),~WAY);
else
setBlockState(pipe->at(i),WAY);
}
emit BreakPipe(pipe);
emit UpdatePipeDisplay();
}
}
}
void getScreenBytes(unsigned char* bytes)
{
int c64bytes = getScreenBytesSize();
memset(bytes, 0, c64bytes);
int width = getWidth();
int height = getHeight();
for (int h = 0; h < height; h++)
{
for (int w = 0; w < width; w++)
{
//printf("src %d = %d\n", h*width+w, src[h*width+w]);
int xblock = w / xBlockSize;
int yblock = h / yBlockSize;
Pixel* p = pixelAt(w, h);
// determine bitmask based on the palette index
// bgcolor = 0x00
// fgcolor = 0x03
// block color 0 = 0x01
// block color 1 = 0x02
unsigned char mask = 0;
if (p->palette_index == bgcolor)
{
mask = 0x00;
}
else if (p->palette_index == fgcolor)
{
mask = 0x03;
}
else if (p->palette_index == getBlockColor(xblock, yblock, 0))
{
mask = 0x01;
}
else if (p->palette_index == getBlockColor(xblock, yblock, 1))
{
mask = 0x02;
}
else
{
printf("this should not happen.");
}
// set bits in bitmap byte
int screen_width = w*2;
int row = h / 8;
int c = screen_width / 8;
int line = h & 7;
int bit = 7 - (screen_width & 7);
int byte = row*320 + c*8 + line;
unsigned char b = bytes[byte];
// raise 2 bits (fg color)
bit--;
if (bit < 0)
bit = 0;
unsigned char shifted_mask = mask << bit;
b = b | shifted_mask;
bytes[byte] = b;
}
}
}