void Map::createBlankMap(int sizeX, int sizeY, int nbPlayer) { std::vector<Tile> mapLine; srand(time(NULL)); if (!_map.empty()) { while (!_map.empty()) _map.pop_back(); } for (int i = 0; i < sizeX; i++) { mapLine.clear(); for (int j = 0; j < sizeY; j++) { if ((i == 0) || (i == sizeX -1) || (j == 0) || (j == sizeY -1)) mapLine.push_back(Tile::WALL); else mapLine.push_back(Tile::EMPTY); } _map.push_back(mapLine); } if (nbPlayer >= 0) putPlayer(sizeX, sizeY, nbPlayer); fillBlock(sizeX, sizeY); this->printMap(); }
void CEgIStream::fillBuf() { long bytes = mReadBufSize; Dim( bytes ); mNextPtr = getCStr(); mBufPos = mPos; if ( long(length()) < bytes ) // Verify that we dimmed ok bytes = length(); fillBlock( mPos, getCStr(), bytes ); if ( bytes <= 0 ) throwErr( cEOSErr ); mStrLen = bytes; // Our str len could have only gotten shorter }
KateBufBlock::KateBufBlock ( KateBuffer *parent, KateBufBlock *prev, KateBufBlock *next, KateFileLoader *stream ) : m_state (KateBufBlock::stateDirty), m_startLine (0), m_lines (0), m_vmblock (0), m_vmblockSize (0), m_parent (parent), m_prev (prev), m_next (next), list (0), listPrev (0), listNext (0) { // init startline + the next pointers of the neighbour blocks if (m_prev) { m_startLine = m_prev->endLine (); m_prev->m_next = this; } if (m_next) m_next->m_prev = this; // we have a stream, use it to fill the block ! // this can lead to 0 line blocks which are invalid ! if (stream) { // this we lead to either dirty or swapped state fillBlock (stream); } else // init the block if no stream given ! { // fill in one empty line ! KateTextLine::Ptr textLine = new KateTextLine (); m_stringList.push_back (textLine); m_lines++; // if we have allready enough blocks around, swap one if (m_parent->m_loadedBlocks.count() >= KateBuffer::maxLoadedBlocks()) m_parent->m_loadedBlocks.first()->swapOut(); // we are a new nearly empty dirty block m_state = KateBufBlock::stateDirty; m_parent->m_loadedBlocks.append (this); } }
long CEgIStream::GetBlock( void* destPtr, unsigned long inBytes ) { long bytesRead = inBytes; if ( mIsTied ) { if ( - mPos >= long(inBytes) ) UtilStr::Move( destPtr, mNextPtr, bytesRead ); else { bytesRead = 0; throwErr( cTiedEOS ); } } else if ( mPos >= mBufPos && mPos + bytesRead <= long(mBufPos + mStrLen) ) UtilStr::Move( destPtr, mNextPtr, bytesRead ); else fillBlock( mPos, destPtr, bytesRead ); mPos += bytesRead; mNextPtr += bytesRead; return bytesRead; }
void xbrz::nearestNeighborScale(const uint32_t* src, int srcWidth, int srcHeight, int srcPitch, uint32_t* trg, int trgWidth, int trgHeight, int trgPitch, SliceType st, int yFirst, int yLast) { if (srcPitch < srcWidth * static_cast<int>(sizeof(uint32_t)) || trgPitch < trgWidth * static_cast<int>(sizeof(uint32_t))) { assert(false); return; } switch (st) { case NN_SCALE_SLICE_SOURCE: //nearest-neighbor (going over source image - fast for upscaling, since source is read only once yFirst = std::max(yFirst, 0); yLast = std::min(yLast, srcHeight); if (yFirst >= yLast || trgWidth <= 0 || trgHeight <= 0) return; for (int y = yFirst; y < yLast; ++y) { //mathematically: ySrc = floor(srcHeight * yTrg / trgHeight) // => search for integers in: [ySrc, ySrc + 1) * trgHeight / srcHeight //keep within for loop to support MT input slices! const int yTrg_first = ( y * trgHeight + srcHeight - 1) / srcHeight; //=ceil(y * trgHeight / srcHeight) const int yTrg_last = ((y + 1) * trgHeight + srcHeight - 1) / srcHeight; //=ceil(((y + 1) * trgHeight) / srcHeight) const int blockHeight = yTrg_last - yTrg_first; if (blockHeight > 0) { const uint32_t* srcLine = byteAdvance(src, y * srcPitch); uint32_t* trgLine = byteAdvance(trg, yTrg_first * trgPitch); int xTrg_first = 0; for (int x = 0; x < srcWidth; ++x) { int xTrg_last = ((x + 1) * trgWidth + srcWidth - 1) / srcWidth; const int blockWidth = xTrg_last - xTrg_first; if (blockWidth > 0) { xTrg_first = xTrg_last; fillBlock(trgLine, trgPitch, srcLine[x], blockWidth, blockHeight); trgLine += blockWidth; } } } } break; case NN_SCALE_SLICE_TARGET: //nearest-neighbor (going over target image - slow for upscaling, since source is read multiple times missing out on cache! Fast for similar image sizes!) yFirst = std::max(yFirst, 0); yLast = std::min(yLast, trgHeight); if (yFirst >= yLast || srcHeight <= 0 || srcWidth <= 0) return; for (int y = yFirst; y < yLast; ++y) { uint32_t* trgLine = byteAdvance(trg, y * trgPitch); const int ySrc = srcHeight * y / trgHeight; const uint32_t* srcLine = byteAdvance(src, ySrc * srcPitch); for (int x = 0; x < trgWidth; ++x) { const int xSrc = srcWidth * x / trgWidth; trgLine[x] = srcLine[xSrc]; } } break; } }