Losowe współrzędne :: 4programmers.net

0

Witam,
próbuje wygenerować losowane współrzędne w tablicy 2D, tak by możliwa była z nimi interakcja. Poniżej zamieszczam fragment kodu odpowiadający za wygenerowanie 1 pkt. i interakcję z nim.

 
void vector2::losowy_pkt(void)
{
    srand ( time(NULL) );
    x_1 = (rand() % wymiar) + 1;
    y_1 = (rand() % wymiar) + 1;
}
//////////////////////////////////////warunek "zmieniający" czyste pole tablice na zawierające element
if(i==x_1 && j==y_1)
/////////////////////////////////////wywołanie funkcji poprzez nałożenie bieżącej pozycji i losowego elementu.
if(pol_x==x_1 && pol_y==y_1)
                nakladanie();

Zacząłem od wygenerowanie tychże pkt.:

 
void vector2::losowe_pkt(void)
{

    for(int i=1;i<=rozmiar;i++)
    {
        x_2[i] = (rand() % wymiar) + 1;
        y_2[i] = (rand() % wymiar) + 1;
    }
}

jednakże późniejsze próby pisania warunków były bezskuteczne, tj. mimo wygenerowanie pkt. nie wiedziałem jak się do nich odwołać w 2 warunku. Proszę o sugestie.

0

Może tak ?

 
#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

struct p2d
{
    int x,y;
};

void losujPunkty2D(int wymiar, p2d *p)
{
    for(int i = 0; i < wymiar; i++)
    {
        p[i].x = rand() % wymiar;
        p[i].y = rand() % wymiar;
    }
}

void czytajPunkty2D(int wymiar, p2d *p)
{
    for(int i = 0; i < wymiar; i++)
    {
        cout << "Punkt[" << i << "] - X: " << p[i].x << ", Y:" << p[i].y << "\n";
    }
}


int main()
{
    srand(time(0));
    p2d points[7];

    losujPunkty2D(7, points);
    czytajPunkty2D(7, points);
    return 0;
}

0

Nie do końca. Tak wygląda funkcja rysujące planszę po każdym ruchu:

 
void vector2::rysuj(p2d *p)
{

    int n=wymiar;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==p[i].x && j==p[j].y) // warunek odpowiedzialny za rys kilku pkt.
            {
                cout.width(4);
                cout << "[#]";
                continue;
            }
            if(i==pol_x && j==pol_y)
            {
                cout.width( 4 );
                cout << "[x]";
                continue;
            }
            if(i==x_1 && j==y_1)
            {
                cout.width(4);
                cout << "[o]";
                continue;
            }

            cout.width( 4 );
            cout << "[ ]";
        }
        cout << "\n";
    }


}

Przy powyższym warunku pkt. nie pojawiają się na planszy.

Dokonałem pewnym zmian:

 
void vector2::rysuj(p2d *p)
{
    int k=0;
    int n=wymiar;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==p[k].x || j==p[k].y)
            {
                cout.width(4);
                cout << "[#]";
                continue;
            }
            if(i==pol_x && j==pol_y)
            {
                cout.width( 4 );
                cout << "[x]";
                continue;
            }
            if(i==x_1 && j==y_1)
            {
                cout.width(4);
                cout << "[o]";
                continue;
            }

            cout.width( 4 );
            cout << "[ ]";

        }
        cout << "\n";
        k++;
    }


}

Jak "zagęścić" planszę pkt.? Problemem jest dalej sprawdzenie, czy bieżąca pozycja jest tożsama, z pozycją wygenerowanego obiektu. Oto nieudana próba:

void vector2::sterowanie(p2d *p)
{

    if(deklaracja_pozycji != true)
        pol_x = 1,pol_y = 1;
    rysuj(points);
    cout << "Uzyj WSAD, by sie przemiescic. By zakonczyc wcisnij 'z;':\n";
    while(true)
        {
            cin >> kursor;
            wybor();

            if(pol_x==x_1 && pol_y==y_1) //warunek sprawdzający dla pkt. - działa
                nakladanie();
            for(int i=0;i<rozmiar;i++) //warunek sprawdzający dla wielu pkt. - niedziała
            {
                if(pol_x==p[i].x && pol_y==p[i].y)
                    nakladanie();
            }
            if(kursor == 'z' )
                break;

        }
}

0

Kolejny raz zmieniłem warunek na:

for(int m=1;m<=n;m++)
            {
                if(i==p[m].x && j==p[m].y)
                {
                    cout.width(4);
                    cout << "[#]";
                    continue;

                }

            }

Tym razem wszystko wydaje się działać, gdyby nie to że powyższy kod tworzy nowe pole, a nie zmienia pustego tj. "[ ]". Poniżej zamieszczam cały kod dla lepszego zobrazowania problemu.

#include <iostream>
#include "plansza.h"

using namespace std;

int main()
{
    srand ( time(NULL) );

    vector2 ruch;
    char wybor;
    cout << "MENU:\n";
    ruch.tworzenie_planszy();
    ruch.losowy_pkt();
    losujPunkty2D(10, points);
    czytajPunkty2D(10, points);

    while(true)
    {
        cout << "1.Wyswietl wspolrzedne\n2.Przemieszczenie\n3.Ruch\n4.Wyjscie\n\n";
        cin >> wybor;
        switch(wybor)
        {
            case '1':
                ruch.wyswietl_wspolrzedne();
                break;
            case '2':
                ruch.podaj_wspolrzedne();
                break;
            case '3':
                ruch.sterowanie(points);
                break;
            case '4':
                return 0;
            default:
                break;
        }
    }
}

#ifndef PLANSZA_H_INCLUDED
#define PLANSZA_H_INCLUDED

#define rozmiar 10

using namespace std;

struct p2d;


class vector2
{
    private:
        int x,y;
    public:
        int pol_x, pol_y;
        int wymiar;
        int x_1, y_1;
        int x_2[rozmiar],y_2[rozmiar];
        char kursor;
        bool deklaracja_pozycji;
////////////////////////////////////////////

        void rysuj(p2d *);
        void tworzenie_planszy(void);
        void losowy_pkt(void);
        void losowe_pkt(void);
        void wyswietl_wspolrzedne(void);
        void podaj_wspolrzedne(void);
        void sterowanie(p2d *);
        void wybor(void);
        void nakladanie(void);



};

struct p2d
{
    int x,y;
};

p2d points[10];

void losujPunkty2D(int wymiar, p2d *p)
{
    for(int i = 0; i < wymiar; i++)
    {
        p[i].x = rand() % wymiar;
        p[i].y = rand() % wymiar;
    }
}

void czytajPunkty2D(int wymiar, p2d *p)
{
    for(int i = 0; i < wymiar; i++)
    {
        cout << "Punkt[" << i << "] - X: " << p[i].x << ", Y:" << p[i].y << "\n";
    }
}



void vector2::rysuj(p2d *p)
{
    int k=0;
    int n=wymiar;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
           /* if(i==p[].x && j==p[].y)
            {
                cout.width(4);
                cout << "[#]";
                continue;
            }*/
            for(int m=1;m<=n;m++)
            {
                if(i==p[m].x && j==p[m].y)
                {
                    cout.width(4);
                    cout << "[#]";
                    continue;

                }

            }

            if(i==pol_x && j==pol_y)
            {
                cout.width( 4 );
                cout << "[x]";
                continue;
            }
            if(i==x_1 && j==y_1)
            {
                cout.width(4);
                cout << "[o]";
                continue;
            }

            cout.width( 4 );
            cout << "[ ]";



        }
        cout << "\n";

    }


}

void vector2::losowy_pkt(void)
{
    x_1 = (rand() % wymiar) + 1;
    y_1 = (rand() % wymiar) + 1;
}

void vector2::losowe_pkt(void)
{

    for(int i=1;i<=rozmiar;i++)
    {
        x_2[i] = (rand() % wymiar) + 1;
        y_2[i] = (rand() % wymiar) + 1;
    }
}
void vector2::tworzenie_planszy(void)
{
    cout << "Podaj rozmiar planszy:\n";
    while(true)
    {
        cin >> wymiar;
        if(wymiar <=18)
            break;
        else
            cout << "Wymiar planszy nie moze przekraczac 18\n";
    }
    int plansza[wymiar][wymiar];
    cout << endl;

}

void vector2::wyswietl_wspolrzedne(void)
{
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
}

void vector2::podaj_wspolrzedne(void)
{
    deklaracja_pozycji = true;
    cout << "Podaj wspolrzedne: x i y:\n";
    cin >> x;
    cin >> y;
    pol_x = x;
    pol_y = y;
    rysuj(points);
    if(pol_x==x_1 && pol_y==y_1)
        nakladanie();

}

void vector2::sterowanie(p2d *p)
{

    if(deklaracja_pozycji != true)
        pol_x = 1,pol_y = 1;
    rysuj(points);
    cout << "Uzyj WSAD, by sie przemiescic. By zakonczyc wcisnij 'z;':\n";
    while(true)
        {
            cin >> kursor;
            wybor();

            if(pol_x==x_1 && pol_y==y_1)
                nakladanie();
            for(int i=0;i<rozmiar;i++)
            {
                if(pol_x==p[i].x && pol_y==p[i].y)
                    nakladanie();
            }
            if(kursor == 'z' )
                break;

        }
}

void vector2::wybor(void)
{
    switch(kursor)
    {
    case 's':
    case 'S':
            if(pol_x >=wymiar)
                break;
           pol_x=pol_x+1 ;
        break;
    case 'w':
    case 'W':
            if(pol_x <=1)
                break;
             pol_x=pol_x-1 ;
        break;
    case 'a':
    case 'A':
            if(pol_y <=1)
                break;
             pol_y=pol_y-1 ;
        break;
    case 'd':
    case 'D':
            if(pol_y >=wymiar)
                break;
             pol_y=pol_y+1 ;
        break;


    }
    rysuj(points);

}


void vector2::nakladanie(void)
{
    cout << "bazinga" << endl;
}



#endif // PLANSZA_H_INCLUDED

Losowe współrzędne

1 użytkowników online, w tym zalogowanych: 0, gości: 1

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami