std::vector<Entity> ChunkGeneratorSystem::generateChunk( Engine& engine, World& world, const Position2d& chunkPositionInChunks )
	{
		std::vector<Entity> entities;
		const auto count = Constants::CHUNK_SIZE / Constants::TILE_SIZE;

		for( int x = 0; x < count; ++x )
			for( int y = 0; y < count; ++y )
			{
				auto tile = world.createNewSaveableEntity( engine, world, engine.randomNumberGenerator.getRandomInt( 101, 103 ) );//grass
				auto transform = tile.getComponent<Transformation>();
				auto graphics = tile.getComponent<Graphics>();

				int chunkPositionInPixelX = chunkPositionInChunks.x*Constants::CHUNK_SIZE;
				int chunkPositionInPixelY = chunkPositionInChunks.y*Constants::CHUNK_SIZE;
				int tilePositionRelativeToChunkInPixelX = transform->getSize().x*x;
				int tilePositionRelativeToChunkInPixelY = transform->getSize().y*y;
				tilePositionRelativeToChunkInPixelX += transform->getSize().x / 2;
				tilePositionRelativeToChunkInPixelY += transform->getSize().y / 2;

				Position2d tilePosition( chunkPositionInPixelX + tilePositionRelativeToChunkInPixelX,
										 chunkPositionInPixelY + tilePositionRelativeToChunkInPixelY,
										 //Constants::STANDART_TILE_ZVALUE,
										 chunkPositionInChunks.worldLayer );

				transform->setPosition( tilePosition );
				graphics->setZValue( -1 );

				entities.push_back( move( tile ) );
			}

		return entities;
	}
Example #2
0
void Eraser::doErase(bool continuation) {
    Tilelayer *tl = currentTilelayer();
    const QPoint tilePos = tilePosition();
    QRegion eraseRegion(tilePos.x(), tilePos.y(), 1, 1);

    if (continuation) {
        foreach (const QPoint &p, pointsOnLine(mLastTilePos, tilePos)) {
            eraseRegion |= QRegion(p.x(), p.y(), 1, 1);
        }
    }
Example #3
0
        mErasing = false;
    }
}

void Eraser::languageChanged() {

}

void Eraser::doErase(bool continuation) {
    Tilelayer *tl = currentTilelayer();
    const QPoint tilePos = tilePosition();
    QRegion eraseRegion(tilePos.x(), tilePos.y(), 1, 1);

    if (continuation) {
        foreach (const QPoint &p, pointsOnLine(mLastTilePos, tilePos)) {
            eraseRegion |= QRegion(p.x(), p.y(), 1, 1);
        }
    }

    mLastTilePos = tilePosition();

    if (!tl->bounds().intersects(eraseRegion.boundingRect()))
        return;

    EraseTiles *erase = new EraseTiles(document(), tl, eraseRegion);
    erase->setMergeable(continuation);

    document()->undoStack()->push(erase);
    document()->emitRegionEdited(eraseRegion, tl);
}
Example #4
0
void Waveform::paintEvent(QPaintEvent * /*event*/)
{
    QPainter painter(this);

    painter.fillRect(rect(), Qt::black);

    if (m_active) {
        WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent"
                             << "windowPosition" << m_windowPosition
                             << "windowLength" << m_windowLength;
        qint64 pos = m_windowPosition;
        const qint64 windowEnd = m_windowPosition + m_windowLength;
        int destLeft = 0;
        int destRight = 0;
        while (pos < windowEnd) {
            const TilePoint point = tilePoint(pos);
            WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent" << "pos" << pos
                                 << "tileIndex" << point.index
                                 << "positionOffset" << point.positionOffset
                                 << "pixelOffset" << point.pixelOffset;

            if (point.index != NullIndex) {
                const Tile &tile = m_tiles[point.index];
                if (tile.painted) {
                    const qint64 sectionLength = qMin((m_tileLength - point.positionOffset),
                                                     (windowEnd - pos));
                    Q_ASSERT(sectionLength > 0);

                    const int sourceRight = tilePixelOffset(point.positionOffset + sectionLength);
                    destRight = windowPixelOffset(pos - m_windowPosition + sectionLength);

                    QRect destRect = rect();
                    destRect.setLeft(destLeft);
                    destRect.setRight(destRight);

                    QRect sourceRect(QPoint(), m_pixmapSize);
                    sourceRect.setLeft(point.pixelOffset);
                    sourceRect.setRight(sourceRight);

                    WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent" << "tileIndex" << point.index
                                         << "source" << point.pixelOffset << sourceRight
                                         << "dest" << destLeft << destRight;

                    painter.drawPixmap(destRect, *tile.pixmap, sourceRect);

                    destLeft = destRight;

                    if (point.index < m_tiles.count()) {
                        pos = tilePosition(point.index + 1);
                        WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent" << "pos ->" << pos;
                    } else {
                        // Reached end of tile array
                        WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent" << "reached end of tile array";
                        break;
                    }
                } else {
                    // Passed last tile which is painted
                    WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent" << "tile" << point.index << "not painted";
                    break;
                }
            } else {
                // pos is past end of tile array
                WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent" << "pos" << pos << "past end of tile array";
                break;
            }
        }

        WAVEFORM_PAINT_DEBUG << "Waveform::paintEvent" << "final pos" << pos << "final x" << destRight;
    }
}