[SFML 2.0] Wyświetlanie fragmentu grafiki

#include "menu.h"
#include "spalanie.h"

#include <SFML/Graphics.hpp>
#include <iostream>
#include <sstream>


void menu( sf::RenderWindow * oknoAplikacji )
{
    oknoAplikacji->setActive( true );
   
    sf::Clock stoper;
    bool dzialaj = true;
   
    sf::Texture tekstura;
    if( !tekstura.loadFromFile( "obrazek.jpg" ) ) //Wczytywanie tekstury
         dzialaj = false;
    //, sf::IntRect(10,10,32,32) //laduje czesc obrazka
    //tekstura.setSmooth(true); //Wygladzanie krawedzi
    sf::Sprite sprajt; //Tworzenie sprajta
    sprajt.setTexture( tekstura ); //Ladujemy teksture do
    sprajt.setPosition( 600, 30 );
   
   
   
    sf::Texture teksturaDoUzywania;
    sf::Sprite sprajtDoUzywania;
   
   
    sf::RectangleShape prostokat( sf::Vector2f( 120, 50 ) );
    //prostokat.setFillColor(sf::Color(100, 250, 50));
    prostokat.setPosition( 600, 30 );
   
   
    bool spalanie = false;
   
    while( dzialaj )
    {
        sf::Event zdarzenie;
        while( oknoAplikacji->pollEvent( zdarzenie ) ) {
            switch( zdarzenie.type ) {
               
            case sf::Event::Closed:
                dzialaj = false;
                break;
               
            case sf::Event::KeyPressed:
                if( zdarzenie.key.code == sf::Keyboard::Escape )
                     dzialaj = false;
               
                break;
               
            case sf::Event::LostFocus: //Okno stracilo zaznaczenie
                dzialaj = false;
                break;
            }
        }
       
       
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::S ) ) {
            if( sf::Mouse::isButtonPressed( sf::Mouse::Left ) )
            {
                sf::Image zrzutEkranu = oknoAplikacji->capture(); ///Zrzuca obraz ekranu do obrazka
                teksturaDoUzywania.loadFromImage( zrzutEkranu, sf::IntRect( pozycjaMyszyWzgledemOkna1.x - 80 + 1, pozycjaMyszyWzgledemOkna1.y - 60 + 1, pozycjaMyszyWzgledemOkna1.x + 80 - 20, pozycjaMyszyWzgledemOkna1.y + 60 - 20 ) );
               
                //pozycjaMyszyWzgledemOkna1 = sf::Mouse::getPosition( *oknoAplikacji );
                spal( pozycjaMyszyWzgledemOkna1.x - 80 + 1, pozycjaMyszyWzgledemOkna1.y - 60 + 1, pozycjaMyszyWzgledemOkna1.x + 80 - 20, pozycjaMyszyWzgledemOkna1.y + 60 - 20, pozycjaMyszyWzgledemOkna1.x, pozycjaMyszyWzgledemOkna1.y );
                //std::cout << "poszlo" << std::endl;
                spalanie = true;
               
                sprajt.setPosition( pozycjaMyszyWzgledemOkna1.x - 80, pozycjaMyszyWzgledemOkna1.y - 60 );
            }
            else if( sf::Keyboard::isKeyPressed( sf::Keyboard::Up ) ) {
                opcjaSpalania( 1 );
                while( sf::Keyboard::isKeyPressed( sf::Keyboard::Up ) ) { }
            }
            else if( sf::Keyboard::isKeyPressed( sf::Keyboard::Down ) ) {
                opcjaSpalania( - 1 );
                while( sf::Keyboard::isKeyPressed( sf::Keyboard::Down ) ) { }
            }
        }
       
       
        oknoAplikacji->clear( sf::Color::White );
       
       
        if( spalanie )
        {
            oknoAplikacji->draw( sprajt );
            spalanie = spalaj( &* oknoAplikacji, & prostokat, & teksturaDoUzywania );
        }
       
        oknoAplikacji->display();
    }
}

#include "spalanie.h"

#include <SFML/Graphics.hpp>
#include <cstdlib>
#include <iostream>

int xKoniec, yKoniec, xPoczatek, yPoczatek, iloscPowtorzen = 0;
int tab[ 800 ][ 600 ];

int jakoscKomputera = 1;
sf::Sprite sprajts;


void opcjaSpalania( int szybkoscSpalania )
{
    if( jakoscKomputera + szybkoscSpalania < 5 && jakoscKomputera + szybkoscSpalania > 0 )
         jakoscKomputera += szybkoscSpalania;
   
}

void spal( int x_Poczatek, int y_Poczatek, int x_Koniec, int y_Koniec, int x_Start, int y_Start )
{
    xPoczatek = x_Poczatek;
    yPoczatek = y_Poczatek;
    xKoniec = x_Koniec - x_Poczatek;
    yKoniec = y_Koniec - y_Poczatek;
   
    iloscPowtorzen = 0;
   
    srand( time( NULL ) );
   
    for( int i = 0; i < xKoniec; i++ ) {
        for( int j = 0; j < yKoniec; j++ ) {
            tab[ i ][ j ] = rand() % 10 + 1;
        }
    }
   
    while( x_Start % jakoscKomputera != 0 )
         x_Start++;
   
    while( x_Poczatek % jakoscKomputera != 0 )
         x_Poczatek++;
   
    while( y_Start % jakoscKomputera != 0 )
         y_Start++;
   
    while( y_Poczatek % jakoscKomputera != 0 )
         y_Poczatek++;
   
   
   
    tab[ x_Start - x_Poczatek ][ y_Start - y_Poczatek ] = 0;
    //tab[x_Start][y_Start]=0;
   
    std::cout << "wpisano " << x_Start << " " << y_Start << std::endl;
}

bool spalaj( sf::RenderWindow * oknoAplikacji, sf::RectangleShape * kwadracik, sf::Texture * wygladEkranuPrzedSpalaniem )
{
    kwadracik->setSize( sf::Vector2f( jakoscKomputera, jakoscKomputera ) ); //Zmienia wymiary prostokata
   
    for( int i = 0; i < xKoniec; i += jakoscKomputera ) {
        for( int j = 0; j < yKoniec; j += jakoscKomputera ) {
            if( tab[ i ][ j ] <= 0 && tab[ i ][ j ] >= - 15 )
            {
                if( i - jakoscKomputera >= 0 )
                if( tab[ i - jakoscKomputera ][ j ] > 0 ) {
                    tab[ i - jakoscKomputera ][ j ] --;
                }
                if( i + jakoscKomputera < xKoniec )
                if( tab[ i + jakoscKomputera ][ j ] > 0 ) {
                    tab[ i + jakoscKomputera ][ j ] --;
                }
                if( j - jakoscKomputera >= 0 )
                if( tab[ i ][ j - jakoscKomputera ] > 0 ) {
                    tab[ i ][ j - jakoscKomputera ] --;
                }
                if( j + jakoscKomputera < yKoniec )
                if( tab[ i ][ j + jakoscKomputera ] > 0 ) {
                    tab[ i ][ j + jakoscKomputera ] --;
                }
               
                tab[ i ][ j ] --;
                if( tab[ i ][ j ] == - 15 )
                     iloscPowtorzen++;
               
            }
           
           
           
            if( tab[ i ][ j ] > - 15 ) {
                sprajts.setTexture( * wygladEkranuPrzedSpalaniem ); //Ladujemy teksture do sprajta
                sprajts.setTextureRect( sf::IntRect( i, j, i + jakoscKomputera, j + jakoscKomputera ) );
                sprajts.setPosition( xPoczatek + i, yPoczatek + j );
                oknoAplikacji->draw( sprajts );
               
                if( tab[ i ][ j ] <= 0 )
                {
                    kwadracik->setFillColor( sf::Color( 0, 0, 0, 0 - tab[ i ][ j ] * 17 ) );
                    kwadracik->setPosition( xPoczatek + i, yPoczatek + j );
                    oknoAplikacji->draw( * kwadracik );
                }
            }
           
        }
    }
    std::cout << "wyswietlono " << iloscPowtorzen << std::endl;
   
    if( iloscPowtorzen <=( xKoniec * yKoniec ) /( jakoscKomputera * jakoscKomputera ) - 50 )
         return true;
    else
         return false;
   
}