void CGeneral::AnimSelfDrawn(const CTile &t) { EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265); UpdateScreen(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265); int i; SDL_Rect dstrect; PlaySound(SND_FLASH); for (i = 0; i < 12; i++) { EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265); EraseArea(dstrect.x, dstrect.y, dstrect.w, 30); dstrect.x = 245; dstrect.y = 235; dstrect.w = m_imgFlash1->w; dstrect.h = m_imgFlash1->h; SDL_BlitSurface(m_imgFlash1, NULL, gpScreen, &dstrect); DrawTile(t, 280, 255); UpdateScreen(20, 235, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 235); UTIL_Delay(50); EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265); EraseArea(dstrect.x, dstrect.y, dstrect.w, 30); dstrect.w = m_imgFlash2->w; dstrect.h = m_imgFlash2->h; SDL_BlitSurface(m_imgFlash2, NULL, gpScreen, &dstrect); DrawTile(t, 280, 255); UpdateScreen(20, 235, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 235); UTIL_Delay(50); } UTIL_Delay(20); EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265); EraseArea(dstrect.x, dstrect.y, dstrect.w, 30); dstrect.w = m_imgFlash1->w; dstrect.h = m_imgFlash1->h; SDL_BlitSurface(m_imgFlash1, NULL, gpScreen, &dstrect); DrawTile(t, 280, 255); DrawUTF8Text(msg("out_selfdrawn"), 215, 265, 2, 255, 255, 255); UpdateScreen(20, 205, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 205); UTIL_Delay(1000); EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265); EraseArea(dstrect.x, dstrect.y, dstrect.w, 30); UpdateScreen(20, 205, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 205); }
//******************************************************************************** bool CExplosionEffect::Draw(SDL_Surface* pDestSurface) //Draw the effect. // //Returns: //True if effect should continue, or false if effect is done. { const UINT dwTimeElapsed = TimeElapsed(); if (dwTimeElapsed >= this->dwDuration) return false; //Effect is done. if (!pDestSurface) pDestSurface = GetDestSurface(); //Draw shrinking explosion. const float fPercent = (this->dwDuration - dwTimeElapsed) / (float)this->dwDuration; ASSERT(fPercent >= 0.0); ASSERT(fPercent <= 1.0); UINT wTile = TI_EXPLOSION_1; if (fPercent < 0.30) wTile = TI_EXPLOSION_4; else if (fPercent < 0.55) wTile = TI_EXPLOSION_3; else if (fPercent < 0.80) wTile = TI_EXPLOSION_2; DrawTile(wTile, pDestSurface); //Continue effect. return true; }
void CMapView::DrawMegaTile(CDC* pDC, int x, int y) { CMapDoc* pDoc = GetDocument(); ASSERT_VALID(pDoc); int r = y * pDoc->GetWidth() + x; CTile Tile = pDoc->GetTile(r); if (m_ViewMode == VIEW_MODE_TILES) { for (int ye = 0; ye < 4; ye++) { for (int xe = 0; xe < 4; xe++) { DrawTile(pDC, x,y,xe,ye, Tile); } } } else { ASSERT(m_ViewMode == VIEW_MODE_ELEVATION); BYTE v = (BYTE)(Tile.Elevation); v = (BYTE)min(255, v*5); // make difference in color more noticable pDC->FillSolidRect(x*40, y*40, 40,40, RGB(v,v,v)); } }
void BuildGameWorld() { HRESULT result; int x, y; LPDIRECT3DSURFACE9 tiles; //load the bitmap image containing all the tiles tiles = LoadSurface("groundtiles.bmp"); //create the scrolling game world bitmap result = d3ddev->CreateOffscreenPlainSurface( GAMEWORLDWIDTH, //width of the surface GAMEWORLDHEIGHT, //height of the surface D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &gameworld, //pointer to the surface NULL); if (result != D3D_OK) { MessageBox(NULL,"Error creating working surface!","Error",0); return; } //fill the gameworld bitmap with tiles for (y=0; y < MAPHEIGHT; y++) for (x=0; x < MAPWIDTH; x++) DrawTile(tiles, MAPDATA[y * MAPWIDTH + x], 64, 64, 16, gameworld, x * 64, y * 64); //now the tiles bitmap is no longer needed tiles->Release(); }
int TerrainSet::Load( MemBuffer &file, const char *setname ) { int rc = -1; if ( file.Read32() == FID_TERRAINSET ) { num_tiles = file.Read16(); for ( int i = 0; i < 10; ++i ) classid[i] = file.Read16(); if ( !LoadTerrainTypes( file ) && !TileSet::Load( file, setname ) ) // create the fog surface. This is kept separate from the tiles // surface so that we don't need to modify the alpha value each // time we want fog fog.Create( TileWidth(), TileHeight(), 16, SDL_SWSURFACE ); fog.SetAlpha( FOG_ALPHA, SDL_SRCALPHA ); fog.SetColorKey( Color(CF_COLOR_WHITE) ); fog.DisplayFormat(); fog.Flood( Color(CF_COLOR_WHITE) ); DrawTile( IMG_FOG, &fog, 0, 0, fog ); rc = 0; } return rc; }
static void RefreshWindow(void) { int xpos, ypos; GrSetGCForeground(gc1, WHITE); GrSetGCBackground(gc1, RED); /* draw the buttons */ GrRect(buttons, gc1, 0, 0, (calc_width - 12)/2, 34); GrRect(buttons, gc1, (calc_width - 8)/2, 0, (calc_width - 12)/2, 34); #if 0 /* for when center align text works */ GrText(buttons, gc1, (calc_width - 10)/4, 22, "Again", 5, 0); GrText(buttons, gc1, (calc_width - 10)*3/4, 22, "Quit", 4, 0); #else GrText(buttons, gc1, 5, 22, "Again", 5, 0); GrText(buttons, gc1, (calc_width / 2) + 5, 22, "Quit", 4, 0); #endif /* draw the tiles */ for (ypos=0; ypos< HEIGHT_IN_TILES; ypos++){ for (xpos=0; xpos< WIDTH_IN_TILES; xpos++){ DrawTile(xpos, ypos); } } }
void CGeneral::DrawTiles(const CTile t[], int num, int x, int y, int dir, int size) { int i; if (dir == COMPUTER_SHOWN) { // Draw computer's tiles in reverse order for (i = num - 1; i >= 0; i--) { DrawTile(t[i], (int)(x + (num - i - 1) * TILE_WIDTH * (size ? 1 : 0.7)), y, dir, size); } } else { // Otherwise draw in normal order for (i = 0; i < num; i++) { DrawTile(t[i], (int)(x + i * TILE_WIDTH * (size ? 1 : 0.7)), y, dir, size); } } }
void cEdiPaint::DrawBrushAt( Brush* brush, int x, int y, float zoom, BOOL anim ) { if(brush==NULL) return; int idx = TileFind(brush->tile); // if(idx==-1) return; iRect map = brush->map; int mw = static_cast<int>(brush->mapWith()); int mh = static_cast<int>(brush->mapHeight()); float ms = brush->mapScale(); if( mw==0 || mh==0 ) return; fRect oldclip = R9_GetClipping(); fRect newclip( (float)x, (float)y, (float)x+zoom*brush->size.x, (float)y+zoom*brush->size.y ); R9_AddClipping(newclip); if(!R9_IsClipping()) { R9_SetClipping(oldclip); return; } // fully clipped if(idx==-1) // no tile { dword color = brush->color & 0xffff40ff; R9_DrawLine( fV2(newclip.p1.x,newclip.p1.y), fV2(newclip.p2.x-1,newclip.p1.y), color ); R9_DrawLine( fV2(newclip.p2.x-1,newclip.p1.y), fV2(newclip.p2.x-1,newclip.p2.y-1), color ); R9_DrawLine( fV2(newclip.p2.x-1,newclip.p2.y-1), fV2(newclip.p1.x,newclip.p2.y-1), color ); R9_DrawLine( fV2(newclip.p1.x,newclip.p2.y-1), fV2(newclip.p1.x,newclip.p1.y), color ); R9_DrawLine( fV2(newclip.p1.x,newclip.p1.y), fV2(newclip.p2.x-1,newclip.p2.y-1), color ); R9_DrawLine( fV2(newclip.p2.x-1,newclip.p1.y), fV2(newclip.p1.x,newclip.p2.y-1), color ); R9_SetClipping(oldclip); return; } int cx = (brush->size.x+mw-1) / mw; int cy = (brush->size.y+mh-1) / mh; int xt=x; for(int i=0;i<cy;i++) { x = xt; for(int j=0;j<cx;j++) { DrawTile( idx, x, y, map, brush->color, brush->flip, brush->frame, brush->shader, zoom*ms ); x+=(int)(zoom*mw); } y+=(int)(zoom*mh); } if(m_brushrect) { dword color = 0xa04040ff; R9_DrawLine( fV2(newclip.p1.x,newclip.p1.y), fV2(newclip.p2.x-1,newclip.p1.y), color ); R9_DrawLine( fV2(newclip.p2.x-1,newclip.p1.y), fV2(newclip.p2.x-1,newclip.p2.y-1), color ); R9_DrawLine( fV2(newclip.p2.x-1,newclip.p2.y-1), fV2(newclip.p1.x,newclip.p2.y-1), color ); R9_DrawLine( fV2(newclip.p1.x,newclip.p2.y-1), fV2(newclip.p1.x,newclip.p1.y), color ); } R9_SetClipping(oldclip); }
/////////////////// // Draw the city void CCity::Draw(CCamera *cCamera) { // Just draw all the tiles tile_t *t = tTiles; int x,y; for(y=0;y<iHeight;y++) for(x=0;x<iWidth;x++) DrawTile(t++); }
//--------------------------------------------------------------------------------- // Draws a 3x3 side of the rubiks cube. as with DrawTile, assumes that all rotation // has already been performed. //--------------------------------------------------------------------------------- void RubiksCube::DrawLine(RubikLine line, int32 x, int32 y, int32 z, int32 size) { //--------------------------------------------------------------------------------- int color; // generate an int to signify tile colour (see enum RC_Color) glBegin(GL_QUADS); //start drawin squares for(int i=0; i<3; i++) { color = line.tile[i].color; //get this tile's colour DrawTile(color, x, y + mulf32(inttof32(i),size), z, size, false); // draw the tile at (i,j) } glEnd(); // stop drawin squares }
void Draw() { DrawBegin(); // Draw the background TODO: Fix glitches over the edge of the level? for (int x=0;x<=(320/16);x++) { for (int y=0;y<=(240/16);y++) { DrawTile(x*16-(xscroll/4)%16,y*16-(yscroll/4)%16, (x+1)*16-(xscroll/4)%16,(y+1)*16-(yscroll/4)%16,17); } } // Draw each tile plane for (IPlane i = Planes.begin(); i != Planes.end(); i++) (*i)->Draw(-xscroll,-yscroll,rsb); // Draw each plumber for (IMover i = Movers.begin(); i != Movers.end(); i++) (*i)->Draw(-xscroll,-yscroll); // Draw each fallers for (IFaller i = Fallers.begin(); i != Fallers.end(); i++) (*i)->Draw(-xscroll,-yscroll); // Diagnostic information HUD if (PBACK->jumping) DrawTile(0,240-16,16,240,484); if (PBACK->jumpthrust>0) DrawTile(16,240-16,32,240,4*32+19); if (diagCollision) DrawTile(32,240-16,48,240,64*32+9); // Relinquish the GL DrawEnd(); static unsigned int errstore=0; glError("Game::Draw()", &errstore); }
void CPlot::RefreshPlot(CDC* pDC) { // 更新布局 RefreshLayout(); // 绘制背景 DrawBackground(pDC); // 绘制坐标轴 DrawAxises(pDC); // 绘制网格 DrawGrids(pDC); // 绘制图例 DrawLegend(pDC,m_rectLegend); // 绘制标题 DrawTile(pDC,m_rectTitle); // 绘制曲线 DrawLines(pDC); }
void XMapLayerImage::Draw( void ) { switch( m_DrawType ) { case xNORMAL: DrawNormal(); break; case xSTRETCH: DrawStretch(); break; case xTILE: DrawTile(); break; default: XBREAK(1); } }
void RenderInfinitePlane(const int tileSize, int nTilesRow, const float y0, const float cam_x, const float cam_z) { int x, z; int x0 = int(cam_x / tileSize); int z0 = int(cam_z / tileSize); x0 *= tileSize; z0 *= tileSize; nTilesRow = int(nTilesRow * 0.5); for(x = x0 - nTilesRow * tileSize; x < x0 + nTilesRow * tileSize; x += tileSize) { for(z = z0 - nTilesRow * tileSize; z < z0 + nTilesRow * tileSize; z += tileSize) { DrawTile(float(x), y0, float(z), float(tileSize)); } } }
//--------------------------------------------------------------------------------- // Draws a 3x3 side of the rubiks cube. as with DrawTile, assumes that all rotation // has already been performed. //--------------------------------------------------------------------------------- void RubiksCube::DrawSide(RubikSide side, int sideNum, int32 x, int32 y, int32 z, int32 size, bool picking) { //--------------------------------------------------------------------------------- int color; // generate an int to signify tile colour (see enum RC_Color) glBegin(GL_QUADS); //start drawin squares for(int i=0; i<3; i++) { for(int j=0; j<3; j++) { color = side.tile[i][j].color; //get this tile's colour if(picking) startCheck(); // if picking... DrawTile( color, x + mulf32(inttof32(i),divf32(size,inttof32(3))), y + mulf32(inttof32(j),divf32(size,inttof32(3))), z, divf32(size,inttof32(3)), picking); // draw the tile at (i,j) if(picking) endCheck(sideNum, i, j); // if picking... } } glEnd(); // stop drawin squares }
void Console::Render() { if( !IsEnabled() ) return; //TODO: Clean up this nonsense static float sTestAlpha = 0.75; Vec2i winDimensions; winDimensions.X = theCamera.GetWindowWidth(); winDimensions.Y = theCamera.GetWindowHeight(); static float fScreenHeightPct = 0.5f; static int sTextBoxBorder = winDimensions.Y/192; static int sTextBoxHeight = winDimensions.Y/32 + sTextBoxBorder; int consoleBGHeight = (int)(fScreenHeightPct * (float)winDimensions.Y); int consoleBGBottomY = consoleBGHeight; glColor4f(0.0f,0.0f,0.0f,sTestAlpha); DrawTile(0, consoleBGBottomY, winDimensions.X, consoleBGHeight ); //Draw log static int sLogXPos = sTextBoxBorder; int logYPos = consoleBGBottomY - sTextBoxBorder; if (_buffer.size() > 0) { glColor4f(1.0f, 1.0f, 1.0f, 1.0f); StringList::iterator it = _buffer.end(); while (it != _buffer.begin()) { it--; /* Vector2 textSize = */ DrawGameText( *it, "ConsoleSmall", sLogXPos, logYPos ); logYPos -= (int)_lineHeight + sTextBoxBorder; } } //Draw text box border glColor4f(0.0f,1.0f,0.0f,sTestAlpha/2.0f); int textBoxBottomY = consoleBGBottomY + sTextBoxHeight; DrawTile(0, textBoxBottomY, winDimensions.X, sTextBoxHeight ); //Draw text box int textBoxHeight = sTextBoxHeight - sTextBoxBorder; int textBoxWidth = winDimensions.X - sTextBoxBorder; int textBoxXPos = (winDimensions.X - textBoxWidth)/2; int textBoxYPos = textBoxBottomY - (sTextBoxHeight-textBoxHeight)/2; glColor4f(0.0f,0.0f,0.0f,sTestAlpha); DrawTile(textBoxXPos, textBoxYPos, textBoxWidth, textBoxHeight); textBoxXPos += sTextBoxBorder; textBoxYPos -= sTextBoxBorder + (sTextBoxBorder/2); glColor4f(0.0f,1.0f,0.0f,1.0f); String printInput = _prompt; printInput += _currentInput.substr(0, _cursorPos); if(_bCursorDisp) { printInput += "|"; } else { printInput += " "; } if (_cursorPos < _currentInput.length()) { printInput += _currentInput.substr(_cursorPos, _currentInput.length()); } DrawGameText(printInput.c_str(), "ConsoleSmall", textBoxXPos, textBoxYPos); //Draw autocomplete static int sMaxAutoCompleteLines = MAX_AUTO_COMPLETE; int numAutoCompleteLines = MathUtil::Min(sMaxAutoCompleteLines, (int)_autoCompleteList.size() ); int autoCompleteBottomY = textBoxBottomY + (numAutoCompleteLines * sTextBoxHeight); int autoCompleteStartY = textBoxBottomY + 2*sTextBoxHeight/3; int autoCompleteXPos = textBoxXPos + winDimensions.Y / 24; int autoCompleteBoxXPos = autoCompleteXPos - sTextBoxBorder; glColor4f(0.0f,0.0f,0.0f,sTestAlpha); DrawTile(autoCompleteBoxXPos, autoCompleteBottomY, winDimensions.X-autoCompleteBoxXPos, numAutoCompleteLines * sTextBoxHeight); glColor4f(0.0f,1.0f,0.0f,1.0f); Vector2 outPos((float)autoCompleteXPos, (float)autoCompleteStartY); for( int i = 0; i < numAutoCompleteLines; i++ ) { if( (int)_autoCompleteList.size() > sMaxAutoCompleteLines-1 && i == sMaxAutoCompleteLines-1 ) DrawGameText( "...", "ConsoleSmall", autoCompleteXPos, (int)outPos.Y ); else DrawGameText( _autoCompleteList[i].c_str(), "ConsoleSmall", autoCompleteXPos, (int)outPos.Y ); outPos.Y += sTextBoxHeight; } }
static void MoveTile(int xpos, int ypos) { /* check all possible moves to see if there is the blank (N,E,S,W) */ if (ypos > 0 && value[xpos][ypos - 1] == MAX_TILES) { value[xpos][ypos - 1] = value[xpos][ypos]; value[xpos][ypos] = MAX_TILES; DrawTile(xpos, ypos - 1); DrawTile(xpos, ypos); } if (xpos < (WIDTH_IN_TILES - 1) && value[xpos + 1][ypos] == MAX_TILES) { value[xpos + 1][ypos] = value[xpos][ypos]; value[xpos][ypos] = MAX_TILES; DrawTile(xpos + 1, ypos); DrawTile(xpos, ypos); } if (ypos < (HEIGHT_IN_TILES - 1) && value[xpos][ypos + 1] == MAX_TILES) { value[xpos][ypos + 1] = value[xpos][ypos]; value[xpos][ypos] = MAX_TILES; DrawTile(xpos, ypos + 1); DrawTile(xpos, ypos); } if (xpos > 0 && value[xpos - 1][ypos] == MAX_TILES) { value[xpos - 1][ypos] = value[xpos][ypos]; value[xpos][ypos] = MAX_TILES; DrawTile(xpos - 1, ypos); DrawTile(xpos, ypos); } /* check for a winner */ if (value[WIDTH_IN_TILES - 1][HEIGHT_IN_TILES - 1] == MAX_TILES) { int winner = 0; for (ypos=0; ypos< HEIGHT_IN_TILES; ypos++){ for (xpos=0; xpos< WIDTH_IN_TILES; xpos++){ if (value[xpos][ypos] == winner + 1) winner++; else winner=0; } } if (winner == MAX_TILES) { /* Do winning screen */ int loop = MAX_TILES; for(loop=0; loop < MAX_TILES; loop++) { for(winner=0; winner < (MAX_TILES - loop) ; winner++) { /* move tiles around */ xpos = winner % WIDTH_IN_TILES; ypos = (int)(winner/WIDTH_IN_TILES); value[xpos][ypos] = loop + winner + 1; DrawTile(winner % WIDTH_IN_TILES, (int)(winner/WIDTH_IN_TILES)); } GrFlush(); for(winner=0; winner < 10000000 ; winner++); /* delay loop */ } /* Print message */ GrSetGCForeground(gc1, WHITE); GrSetGCBackground(gc1, RED); GrText(tiles, gc1, ((WIDTH_IN_TILES * tile_width)/2) - 40, (HEIGHT_IN_TILES * tile_height)/2, "Well Done!!", -1, 0); } } }
void Tileset::DrawRandom(RenderDevice::Renderer & render, int x, int y) { DrawTile(render, rand() % _numTiles + 1, x, y); }
void LevelView::DrawTile(Tile * tile, HDC hdc, RECT rect) { DrawTile(tile, hdc, rect, 0, 0); }
void LevelView::DrawTile(Tile * tile, HDC hdc, RECT rect, int offsetX) { DrawTile(tile, hdc, rect, offsetX, 0); }
void Plumber :: Draw(int xof, int yof) { if (spinning) { spinface++; spinface%=8; DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-32, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof-16, 512+((spinface/2)%2)*(spinface>3?2:1)+32*(small?0:2)); DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-16, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof, 512+((spinface/2)%2)*(spinface>3?2:1)+32*(small?1:3)); } else if (ducking) { DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-32, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof-16, 512+6+32*(small?0:2)); DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-16, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof, 512+6+32*(small?1:3)); } else if (jumping && vy <=0) { DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-32, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof-16, 512+4+32*(small?0:2)); DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-16, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof, 512+4+32*(small?1:3)); } else if (jumping && vy > 0) { DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-32, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof-16, 512+5+32*(small?0:2)); DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-16, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof, 512+5+32*(small?1:3)); } else if ((left && vx<=0)||(!left&&vx>=0)) { DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-32, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof-16, 512+(step?0:3)+32*(small?0:2)); DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-16, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof, 512+(step?0:3)+32*(small?1:3)); } else { DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-32, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof-16, 512+8+32*(small?0:2)); DrawTile(int(x+P_X_OFF) +(left? 16:0) +xof, int(y+P_Y_OFF) +yof-16, int(x+P_X_OFF) +(left? 0:16) +xof, int(y+P_Y_OFF) +yof, 512+8+32*(small?1:3)); } }
void LevelView::Draw(HDC hDC, RECT rect, int xFrom, int xTo) { if(!pWorld->Instance()->menu) { if(myTiles != NULL) { // iterate trew all tiles vector<Tile*>::iterator iterator = myTiles->begin(); while(iterator!=myTiles->end()) { Tile * tile = *iterator; if(ShouldDrawTile(tile, xFrom, xTo)) DrawTile(tile, hDC, rect, -1 * xFrom); iterator++; } } #pragma region surfaces if(Renderer::ShowSurfaces) { vector<Surface*> tempList; if(surfaces != NULL) { vector<Surface*>::iterator surfIterator = surfaces->begin(); while(surfIterator != surfaces->end()) { Surface * surf = *surfIterator; tempList.push_back(surf); surfIterator++; } } HPEN hPen = CreatePen(PS_SOLID, 1, RGB(255, 25, 5)); HPEN hPenIce = CreatePen(PS_SOLID, 1, RGB(25, 5, 255)); HPEN cloud = CreatePen(PS_DOT, 1, RGB(255, 25, 5)); HPEN cloudIce = CreatePen(PS_DOT, 1, RGB(25, 5, 255)); SelectObject(hDC, hPen); vector<Surface*>::iterator surfIterator = tempList.begin(); while(surfIterator != tempList.end()) { Surface * surface = *surfIterator; if(surface->isIce) if(surface->isCloud) SelectObject(hDC, cloudIce); else SelectObject(hDC, hPenIce); else if(surface->isCloud) SelectObject(hDC, cloud); else SelectObject(hDC, hPen); if(surface->isSlope!=0) { if (surface->isSlope==1) { MoveToEx(hDC,surface->xFrom - xFrom, surface->yFrom,NULL); LineTo(hDC,surface->xTo - xFrom, surface->yFrom + (surface->yTo - surface->yFrom)); } else { MoveToEx(hDC,surface->xFrom - xFrom, surface->yTo,NULL); LineTo(hDC,surface->xTo - xFrom, surface->yTo+ (surface->yFrom - surface->yTo)); } } else Rectangle(hDC, surface->xFrom - xFrom, surface->yFrom, surface->xTo - xFrom, surface->yFrom + (surface->yTo - surface->yFrom)); surfIterator++; } DeleteObject(hPen); DeleteObject(cloud); DeleteObject(hPenIce); DeleteObject(cloudIce); } #pragma endregion #pragma region fps if(Renderer::ShowFps) { SYSTEMTIME now; GetSystemTime(&now); int difInSec = now.wSecond - st.wSecond; int difInMSec = now.wMilliseconds - st.wMilliseconds; int ms1 = now.wMilliseconds; if(difInSec != 0) difInMSec = difInMSec + 1000; ostringstream s; s << "FPS: "; if(difInMSec == 0) s << "1000+"; else { float temp_fps = (float)(1000 / difInMSec); int temp2_fps = (int)temp_fps; s << (temp2_fps); } // cast to c_string LPCSTR fps = ""; string temp; temp = s.str(); fps = temp.c_str(); if(st.wSecond == now.wSecond) TextOut(hDC, 15, 15, fps, strlen(fps)); else TextOut(hDC, 15, 15, "FPS:", strlen("FPS:")); // set the time of the last update to this st = now; } #pragma endregion } }
void CGeneral::AnimOut(const CTile &t) { EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94); UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64); int i; SDL_Rect dstrect, dhand; SDL_Surface *save = SDL_CreateRGBSurface(gpScreen->flags & (~SDL_HWSURFACE), m_imgHand->w, m_imgHand->h, gpScreen->format->BitsPerPixel, gpScreen->format->Rmask, gpScreen->format->Gmask, gpScreen->format->Bmask, gpScreen->format->Amask); dhand.x = 218; dhand.y = 125; dhand.w = m_imgHand->w; dhand.h = m_imgHand->h; SDL_BlitSurface(gpScreen, &dhand, save, NULL); SDL_BlitSurface(m_imgHand, NULL, gpScreen, &dhand); UpdateScreen(dhand.x, dhand.y, dhand.w, dhand.h); PlaySound(SND_FLASH); dhand.h = m_imgFlash2->h - (125 - 94); for (i = 0; i < 10; i++) { EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94); EraseArea(245, 94, m_imgFlash2->w, m_imgFlash2->h); dstrect.x = 245; dstrect.y = 94; dstrect.w = m_imgFlash1->w; dstrect.h = m_imgFlash1->h; SDL_BlitSurface(m_imgFlash1, NULL, gpScreen, &dstrect); DrawTile(t, 280, 104); SDL_BlitSurface(m_imgHand, NULL, gpScreen, &dhand); UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64); UTIL_Delay(50); EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94); EraseArea(dstrect.x, dstrect.y, dstrect.w, dstrect.h); dstrect.w = m_imgFlash2->w; dstrect.h = m_imgFlash2->h; SDL_BlitSurface(m_imgFlash2, NULL, gpScreen, &dstrect); DrawTile(t, 280, 104); SDL_BlitSurface(m_imgHand, NULL, gpScreen, &dhand); UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64); UTIL_Delay(50); } dhand.h = m_imgHand->h; UTIL_Delay(120); DrawUTF8Text(msg("out_discard"), 215, 114, 2, 255, 255, 255); UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64); UTIL_Delay(1000); EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94); EraseArea(dstrect.x, dstrect.y, dstrect.w, dstrect.h); SDL_BlitSurface(save, NULL, gpScreen, &dhand); SDL_FreeSurface(save); UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64); UpdateScreen(dhand.x, dhand.y, dhand.w, dhand.h); }
BOOL TilePropWindow::DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch ( msg ) { case WM_ACTIVATE: if ( LOWORD(wParam) != WA_INACTIVE ) chkd.SetCurrDialog(hWnd); break; case WM_INITDIALOG: { HWND hEdit = GetDlgItem(hWnd, IDC_EDIT_TILEVALUE); SendMessage(hEdit, EM_SETLIMITTEXT, 10, 0); UpdateTile(); PostMessage(hWnd, WM_NEXTDLGCTL, (WPARAM)hEdit, true); return true; } break; case WM_PAINT: { RECT rect; GetClientRect(hWnd, &rect); int width = 32, height = 32; PAINTSTRUCT ps; HDC hDC = BeginPaint(hWnd, &ps), MemhDC = CreateCompatibleDC(hDC); HBITMAP Membitmap = CreateCompatibleBitmap(hDC, width, height); SelectObject(MemhDC, Membitmap); TCHAR lpszTile[11]; int TextLength = WORD(SendDlgItemMessage(hWnd, IDC_EDIT_TILEVALUE, EM_LINELENGTH, 0, 0)); *((LPWORD)lpszTile) = TextLength; SendDlgItemMessage(hWnd, IDC_EDIT_TILEVALUE, EM_GETLINE, 0, (LPARAM)lpszTile); lpszTile[TextLength] = '\0'; u16 tile = atoi(lpszTile), tileset = CM->getTileset(); TileSet* tiles = &chkd.scData.tilesets.set[tileset]; HBRUSH brush = CreateSolidBrush(RGB(166, 156, 132)); FillRect(MemhDC, &rect, brush); DeleteObject(brush); BITMAPINFO bmi = GetBMI(32, 32); DrawTile(MemhDC, tiles, 0, 0, tile, bmi, 0, 0, 0); BitBlt(hDC, 55, 50, width, height, MemhDC, 0, 0, SRCCOPY); BITMAPINFO bmiMini = GetBMI(8, 8); for ( int yMiniTile=0; yMiniTile<4; yMiniTile++ ) { for ( int xMiniTile=0; xMiniTile<4; xMiniTile++ ) DrawMiniTileElevation(hDC, tiles, 350+xMiniTile*9, 50+yMiniTile*9, tile, xMiniTile, yMiniTile, bmiMini); } DeleteObject(Membitmap); DeleteDC (MemhDC); DeleteDC (hDC); } break; case WM_DESTROY: EndDialog(hWnd, IDCANCEL); break; default: return false; break; } return 0; }
/** * Initialize world node. */ HRESULT WorldNode::Initialize(IDirect3DDevice9* pd3dDevice) { WCHAR wsNewPath[ MAX_PATH ]; // search and load floor texture DXUTFindDXSDKMediaFileCch(wsNewPath, sizeof(wsNewPath), m_sFloorFilename.c_str()); if( FAILED(D3DXCreateTextureFromFile( pd3dDevice, wsNewPath, &m_pFloorTexture)) ) { return E_FAIL; } // search and load wall texture DXUTFindDXSDKMediaFileCch(wsNewPath, sizeof(wsNewPath), m_sWallFilename.c_str()); if( FAILED(D3DXCreateTextureFromFile( pd3dDevice, wsNewPath, &m_pWallTexture)) ) { return E_FAIL; } // save grid size iWorldHeight = m_worldFile.GetHeight(); iWorldWidth = m_worldFile.GetWidth(); // draw tiles for each row and column entry for(int col = 0; col < m_worldFile.GetWidth(); col++) { for(int row = 0; row < m_worldFile.GetHeight(); row++) { // compute cube base coordinates float x = col * kWorldScale; float y = 0.0f; float z = row * kWorldScale; // check row/col for cell switch(m_worldFile(row,col)) { case WorldFile::OCCUPIED_CELL: { // draw cube top DrawTile(x, y, z, kWorldScale, kTop, kWall); // check for occupied cells next to cell, draw cube sides if not occupied // left if(m_worldFile(row,col-1) == WorldFile::EMPTY_CELL || m_worldFile(row,col-1) == WorldFile::INVALID_CELL) DrawTile(x, y, z, kWorldScale, kLeft, kWall); // right if(m_worldFile(row,col+1) == WorldFile::EMPTY_CELL || m_worldFile(row,col+1) == WorldFile::INVALID_CELL) DrawTile(x, y, z, kWorldScale, kRight, kWall); // upper if(m_worldFile(row+1,col) == WorldFile::EMPTY_CELL || m_worldFile(row+1,col) == WorldFile::INVALID_CELL) DrawTile(x, y, z, kWorldScale, kUpper, kWall); // lower if(m_worldFile(row-1,col) == WorldFile::EMPTY_CELL || m_worldFile(row-1,col) == WorldFile::INVALID_CELL) DrawTile(x, y, z, kWorldScale, kLower, kWall); break; } default: { // draw floor DrawTile(x, y, z, kWorldScale, kBottom, kFloor); break; } } } } // create vertex declaration HRESULT result = pd3dDevice->CreateVertexDeclaration(m_sCustomVertexDeclaration, &m_pCVDeclaration); return result; }
void TilemapLayer::Draw(int z_order) { if (!visible) return; // Get the number of tiles that can be displayed on window int tiles_x = (int)ceil(DisplayUi->GetWidth() / (float)TILE_SIZE); int tiles_y = (int)ceil(DisplayUi->GetHeight() / (float)TILE_SIZE); // If ox or oy are not equal to the tile size draw the next tile too // to prevent black (empty) tiles at the borders if (ox % TILE_SIZE != 0) { ++tiles_x; } if (oy % TILE_SIZE != 0) { ++tiles_y; } for (int x = 0; x < tiles_x; x++) { for (int y = 0; y < tiles_y; y++) { // Get the real maps tile coordinates int map_x = ox / TILE_SIZE + x; int map_y = oy / TILE_SIZE + y; if (width <= map_x || height <= map_y) continue; int map_draw_x = x * TILE_SIZE - ox % TILE_SIZE; int map_draw_y = y * TILE_SIZE - oy % TILE_SIZE; // Get the tile data TileData &tile = data_cache[map_x][map_y]; int map_draw_z = tile.z; if (map_draw_z > 0) { if (map_draw_z < 9999) { map_draw_z += y * TILE_SIZE; if (y == 0) map_draw_z += TILE_SIZE; } } // Draw the tile if its z is being draw now if (z_order == map_draw_z) { if (layer == 0) { // If lower layer if (tile.ID >= BLOCK_E && tile.ID < BLOCK_E + BLOCK_E_TILES) { int id = substitutions[tile.ID - BLOCK_E]; // If Block E int row, col; // Get the tile coordinates from chipset if (id < 96) { // If from first column of the block col = 12 + id % 6; row = id / 6; } else { // If from second column of the block col = 18 + (id - 96) % 6; row = (id - 96) / 6; } DrawTile(*chipset_screen, map_draw_x, map_draw_y, row, col, false); } else if (tile.ID >= BLOCK_C && tile.ID < BLOCK_D) { // If Block C // Get the tile coordinates from chipset int col = 3 + (tile.ID - BLOCK_C) / 50; int row = 4 + animation_step_c; // Draw the tile DrawTile(*chipset_screen, map_draw_x, map_draw_y, row, col, false); } else if (tile.ID < BLOCK_C) { // If Blocks A1, A2, B // Draw the tile from autotile cache TileXY pos = GetCachedAutotileAB(tile.ID, animation_step_ab); DrawTile(*autotiles_ab_screen, map_draw_x, map_draw_y, pos.y, pos.x, true); } else { // If blocks D1-D12 // Draw the tile from autotile cache TileXY pos = GetCachedAutotileD(tile.ID); DrawTile(*autotiles_d_screen, map_draw_x, map_draw_y, pos.y, pos.x, true); } } else { // If upper layer // Check that block F is being drawn if (tile.ID >= BLOCK_F && tile.ID < BLOCK_F + BLOCK_F_TILES) { int id = substitutions[tile.ID - BLOCK_F]; int row, col; // Get the tile coordinates from chipset if (id < 48) { // If from first column of the block col = 18 + id % 6; row = 8 + id / 6; } else { // If from second column of the block col = 24 + (id - 48) % 6; row = (id - 48) / 6; } // Draw the tile DrawTile(*chipset_screen, map_draw_x, map_draw_y, row, col, false); } } } } } }