Pokaż wiadomości

Ta sekcja pozwala Ci zobaczyć wszystkie wiadomości wysłane przez tego użytkownika. Zwróć uwagę, że możesz widzieć tylko wiadomości wysłane w działach do których masz aktualnie dostęp.


Wiadomości - Nekronomik

Strony: [1] 2 3
1
Allegro / allegro 5.2 lub nowsza (instalacja)
« dnia: Marzec 04, 2018, 14:06:13 »
Witam, czy wie ktoś może jak zainstalować allegro 5.2 w Code Blocks lub dev C++ ?
allegro-5.0.10-mingw-4.7.0 zainstaluję bez problemu ale z allegro 5.2 jest już problem bo oby dwie wersje się różnią ilością plików i wagą i nie wiem jak ją też za linkować.
Tu mam wersje allegro 5 http://liballeg.org/download.html tylko że nie wiem jak je zainstalować.

2
Kiedyś mi ktoś powiedział "najważniejsze że działa" i tak się tego trzymałem ale tak jak lethern napisałeś przy większych projektach pojawiają się schody. Przez to musiałem odpuścić dalsze pisanie swojej gry i zaczynać od nowa z informacjami które uzyskałem na forum. Ale nadal jestem w kropce bo nie wiem jak rozwiązać swój problem na temat tych obiektów. Padły tu już rozwiązania których szczerze powiem-nie rozumiem. Ale za daleko już z tym programowaniem zabrnąłem aby odpuścić sobie tylko dlatego że czegoś nie rozumiem po za tym spodobało mi się programowanie (jakoś się uzależniłem).

3
Moje założenie było takie że chciałem aby wszystkie obiekty miały wspólne współrzędne,życie/wytrzymałość,wielkość niezależnie czy obiektem będzie czołg, samolot, statek ,gracz, beczka, mur itp. wtedy bez problemu miedzy nimi można sprawdzać kolizje i różne działania a jak wiadomo te obiekty nie są sobie równe są metody i zmienne które je wyróżniają od siebie. Myślałem ze mi tu dziedziczenie pomoże w sumie nawet na początku było dobre wystarczyło wszystko tylko rzutować na klasę podstawową, problem już tu się pojawił bo rzutowane było tylko to co było dziedziczone nawet nie były brane pod uwagę odziedziczone metody które posiadały w sobie inne rozwiązanie obliczeniowe. Padły tutaj już rozwiązania jak Czolg* czolg = static_cast<Czolg*>(pojazdy[i]); lub czy_moze_czolg_A = dynamic_cast<Czolg*> ( pojaz1 );niby jakieś to jest rozwiązanie ale gdy będę miał na ekranie koło 300 obiektów które będą między sobą sprawdzały różne zdarzenia i które będą mielone wszystkie 50 razy w ciągu sekundy dojdą jeszcze ich animacje, grafika itp to ja nie wiem czy komputer to uciągnie, samo zlokalizowanie błędu będzie katorgą nie wspominając jak bardzo będzie czytelny kod.
Pisaliście żeby tak dziedziczyć aby czołg nie posiadał metod samolotu tzn. żeby po prostu nie mógł latać albo pływać w sumie racja ale to tak naprawdę odemnie  zależy czy ja mu na to pozwolę. Zwróciłem uwagę na jedna grę warcraft 3 a dokładnie editor map, gdzie w momęcie dodania do mapy np wieśniaka mam możliwość jego edycji i zadecydowania czy wieśniak będzie jednostka latającą, ciężką, magiem nawet domem, lub drzewem. Wychodzi na to że wszystkie atrybuty/metody tego wieśniaka są upchane w jedną klasę do których wieśniak ma dostęp. Wychodzi na to że wieśniak może być wszystkim albo tym czym będę chciał by był.

4
Muszę umieścić funkcje wirtualną o tej samej nazwie  w każdej klasie potomnej jak i tej głównej bo inaczej kompilator się pruje gdy chce wywołać ta funkcje.
Dlaczego "jeśli już trzeba" ? mam zrozumieć że czołg, samolot i statek powinni używać tych samych metod i zmiennych ?

5
czyli z funkcjami wirtualnymi wyglądało by to tak:
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>

using namespace std;

class Pojazd
{
        protected:
                double x;
                double y;
                string nazwa;
                int wytrzymalosc;
                double szybkosc;
                int obrazenia;
        public:
                Pojazd()
                {
                        x=5;
                        y=5;
                }
                void dane() const {cout<<x<<" "<<y<<" "<<nazwa<<" "<<wytrzymalosc<<" "<<szybkosc<<endl;}
                string w_nazwa() const {return nazwa;}
                int w_wytrzymalosc() const {return wytrzymalosc;}
                double w_szybkosc() const {return szybkosc;}
                void otrzymane_obrazenia(int a)
                {
                        wytrzymalosc-=a;
                        if(wytrzymalosc<0) wytrzymalosc=0;
                }
               
                virtual int w_dlugosc_skrzydel()=0;
                virtual int w_dlugosc_kadluba()=0;
                virtual int w_dlugosc_lufy()=0;
                virtual int w_grubosc_pancerza()=0;
};

class Samolot : public Pojazd
{
        public:
                int dlugosc_skrzydel;
        Samolot()
        {
                nazwa="Iskra";
                szybkosc=10;
                wytrzymalosc=100;
                dlugosc_skrzydel=(rand()&200)+50;
                obrazenia=5;
        }
        int w_dlugosc_skrzydel() const {return dlugosc_skrzydel;}
        void ulepsz_dlugosc_skrzydel() { dlugosc_skrzydel+=10;}
       
        virtual int w_dlugosc_skrzydel() {return dlugosc_skrzydel;};
        virtual int w_dlugosc_kadluba() {};
        virtual int w_dlugosc_lufy() {};
        virtual int w_grubosc_pancerza() {};
};
Samolot samolot;

class Statek : public Pojazd
{
        public:
                int dlugosc_kadluba;
        Statek()
        {
                nazwa="Lotniskowiec";
                szybkosc=1.5;
                wytrzymalosc=10000;
                dlugosc_kadluba=(rand()&200)+50;
                obrazenia=50;
        }
        int w_dlugosc_kadluba() const {return dlugosc_kadluba;}
        void ulepsz_dlugosc_kadluba() { dlugosc_kadluba+=10;}
       
        virtual int w_dlugosc_skrzydel() {};
        virtual int w_dlugosc_kadluba() {return dlugosc_kadluba;};
        virtual int w_dlugosc_lufy() {};
        virtual int w_grubosc_pancerza() {};
};
Statek statek;

class Czolg : public Pojazd
{
        public:
                int dlugosc_lufy;
                int grubosc_pancerza;
        Czolg()
        {
                nazwa="Tygrys";
                szybkosc=2;
                wytrzymalosc=500;
                dlugosc_lufy=(rand()&200)+50;
                obrazenia=10;
        }
        int w_dlugosc_lufy() const {return dlugosc_lufy;}
        void ulepsz_dlugosc_lufy() { dlugosc_lufy+=10;}
       
        virtual int w_dlugosc_skrzydel() {};
        virtual int w_dlugosc_kadluba() {};
        virtual int w_dlugosc_lufy() {return dlugosc_lufy;};
        virtual int w_grubosc_pancerza() {return grubosc_pancerza;};
};
Czolg czolg;

int main()
{
vector<Pojazd>pojazdy;

}
w ten sposób bym nie musiał używać
Czolg* czolg = static_cast<Czolg*>(pojazdy);.
Te funkcje wirtualne strasznie śmiecą w kodzie.
Brak dziedziczenia to najlepsza hierarchia klas. Jeśli tylko się da, powinieneś do tego dążyć
W tym przypadku chyba raczej się nie da.

6
Poczytałem na temat vector'ów i problem jest taki że może on przechowywać tylko jeden typ klasy np.
vector<Czolg>pojazd; będzie przechowywał tylko czołgi nie da się widzę aby dodatkowo przechowywał jeszcze statki i samoloty bo:
vector<Czolg>pojazd;
vector<Samolot>pojazd ;
To jest już błąd, można tylko tak
vector<Czolg>pojazd_1;
vector<Samolot>pojazd_2;
vector<Statek>pojazd_3;
Ale tu już sprawa się komplikuje z kodem no i to tak jak bym sam sobie zrobił tablice klas.
Można spróbować z dziedziczeniem i rzutowaniem na pojazd i sam pojazd dodać do vector'a lecz znowu będzie problem aby dostać się do zmiennych i metod klas potomnych.

7
Xender ja bym to najchętniej zrobił tablice klasy pojazd i w niej wszystko trzymał wtedy nie musiał bym się bawić z dziedziczeniem, rzutowaniem jawnym czy ( rzutowaniem w górę o którym mało wiem) czy funkcjach wirtualnych. Ale robił mi się śmietnik w klasie jeden wielki mikser w którym było po prostu wszystko a tu na forum dowiedziałem się o innym rozwiązaniu który już częściowo rozumiem jedyne co mi jeszcze zostało to zrozumieć jak dostać się do danych potomka niby najłatwiejszy sposób to funkcje wirtualne ale przez nie tez mi się burdel robił w kodzie. Na vector'ach się nie znam, nie miałem jeszcze takiej okazji.

8
Czyli w taki sposób powinienem dziedziczyć ?:
class Pojazd
{
protected:
double x;
double y;
string nazwa;
int wytrzymalosc;
double szybkosc;
int obrazenia;
public:
Pojazd()
{
x=5;
y=5;
}
void dane() const {cout<<x<<" "<<y<<" "<<nazwa<<" "<<wytrzymalosc<<" "<<szybkosc<<endl;}
string w_nazwa() const {return nazwa;}
int w_wytrzymalosc() const {return wytrzymalosc;}
double w_szybkosc() const {return szybkosc;}
void otrzymane_obrazenia(int a)
{
wytrzymalosc-=a;
if(wytrzymalosc<0) wytrzymalosc=0;
}
};
Pojazd pojazd;

class Samolot : public Pojazd
{
public:
int dlugosc_skrzydel;
Samolot()
{
nazwa="Iskra";
szybkosc=10;
wytrzymalosc=100;
dlugosc_skrzydel=(rand()&200)+50;
obrazenia=5;
}
int w_dlugosc_skrzydel() const {return dlugosc_skrzydel;}
void ulepsz_dlugosc_skrzydel() { dlugosc_skrzydel+=10;}
};
Samolot samolot;

class Statek : public Pojazd
{
public:
int dlugosc_kadluba;
Statek()
{
nazwa="Lotniskowiec";
szybkosc=1.5;
wytrzymalosc=10000;
dlugosc_kadluba=(rand()&200)+50;
obrazenia=50;
}
int w_dlugosc_kadluba() const {return dlugosc_kadluba;}
void ulepsz_dlugosc_kadluba() { dlugosc_kadluba+=10;}
};
Statek statek;

class Czolg : public Pojazd
{
public:
int dlugosc_lufy;
int grubosc_pancerza;
Czolg()
{
nazwa="Tygrys";
szybkosc=2;
wytrzymalosc=500;
dlugosc_lufy=(rand()&200)+50;
obrazenia=10;
}
int w_dlugosc_lufy() const {return dlugosc_lufy;}
void ulepsz_dlugosc_lufy() { dlugosc_lufy+=10;}
};
Czolg czolg;
Jeśli tak to jeszcze tylko przerobić to będę musiał tak by dokopać się do zmiennych.
Jeśli jeszcze chodzi o czołg to jeśli chciał bym mieć więcej różnych typów nie tylko tygrys to czy zrobić funkcje generującą typy czołgów ? np.
class Czolg : public Pojazd
{
public:
void generator(int a)
{
switch(a)
{
case 1:
nazwa="Tygrys";
break;
case 2:
nazwa="M1 Abrams";
break;
/*
.
.
.
.
*/
case 10:
nazwa="FT-17";
break;
}
}
};
Czy osobno klasy na nich ?

9
Głownie chodziło mi o to że gdy stworze parę obiektów typu tygrys to do każdego z nich bedę miał dostęp do dlugosc_lufy abym mógł sobie korygować jej długość osobno dla każdego tygrysa. Faktycznie wyszło na to że np. niszczyciel też posiada długosc_lufy i dlugosc_skrzydel. Myślałem jeszcze nad tym rozwiązaniem:
class Pojazd
{
protected:
double x;
double y;
string nazwa;
int dlugosc_skrzydel;
int dlugosc_kadluba;
int dlugosc_lufy;
public:
Pojazd()
{
x=5;
y=5;
}
int w_dlugosc_lufy() const { return dlugosc_lufy;}
void zmien_dlugosc_lufy() { dlugosc_lufy=rand()%100;}

int w_dlugosc_kadluba() const { return dlugosc_kadluba;}
void zmien_dlugosc_kadluba() { dlugosc_kadluba=rand()%100;}

int w_dlugosc_skrzydel() const { return dlugosc_skrzydel;}
void zmien_dlugosc_skrzydel() { dlugosc_skrzydel=rand()%100;}

void dane() const {cout<<x<<" "<<y<<" "<<nazwa<<endl;}
string w_nazwa() const {return nazwa;}

};
Pojazd pojazd;

class Vulture : public Pojazd
{
public:
Vulture()
{
nazwa="Vulture";
}
};
Vulture vulture;

class Lotniskowiec : public Pojazd
{
public:
Lotniskowiec()
{
nazwa="Lotniskowiec";
}
};
Lotniskowiec lotniskowiec;

class Tygrys : public Pojazd
{
public:
Tygrys()
{
nazwa="Tygrys";
}
};
Tygrys tygrys;
Ale to działa tak samo jak wcześniejszy kod.
Kombinowałem jeszcze z funkcjami wirtualnymi w sposób taki że sama np klasa Tygrys będzie przechowywała
zmienną int dlugosc_lufy, klasa niszczyciel dlugosc_kadluba no i potem tylko rzutowanie na pojazd ale trzeba wziąć pod uwagę że tych zmiennych może być więcej. Lecz funkcje wirtualne robią mi dosłownie śmietnik w kodzie bo każda klasa musi mieć taką samą nazwę funkcji wirtualnej mimo że nawet nie będzie ona używana bo nie każdy obiekt utworzony czy to będzie tygrys, niszczyciel czy vulture będzie miał taka samą ilość zmiennych.
Jeśli chodzi o main to mogłem napisać komentarz //testy.
lethern w tym kodzie co mi pokazałeś czy naprawdę trzeba tak kombinować aby dokopać się do tych zmiennych ?

10
Projektowanie kodu / Dziedziczenie, czy to jest prawidłowy sposób ?
« dnia: Styczeń 26, 2015, 02:02:07 »
Witam, tak jak w temacie czy dobrze używam dziedziczenia nie czy nie ma błędów ale czy jest to prawidłowo napisane i czy tak można go w ten sposób używać ?
#include<iostream>
#include<string>
#include<cmath>
#include<cstdlib>
#include<ctime>
using namespace std;

class Czolg
{
   private:
      int dlugosc_lufy;
   public:
      int w_dlugosc_lufy() const { return dlugosc_lufy;}
      void zmien_dlugosc_lufy() { dlugosc_lufy=rand()%100;}
};
Czolg czolg;

class Statek
{
   private:
      int dlugosc_kadluba;
   public:
      int w_dlugosc_kadluba() const { return dlugosc_kadluba;}
      void zmien_dlugosc_kadluba() { dlugosc_kadluba=rand()%100;}
};
Statek statek;

class Samolot
{
   private:
      int dlugosc_skrzydel;
   public:
      int w_dlugosc_skrzydel() const { return dlugosc_skrzydel;}
      void zmien_dlugosc_skrzydel() { dlugosc_skrzydel=rand()%100;}
};
Samolot samolot;

class Pojazd : public Czolg, public Statek, public Samolot
{
   protected:
      double x;
      double y;
      string nazwa;
   public:
      Pojazd()
      {
         x=5;
         y=5;
      }
      void dane() const {cout<<x<<" "<<y<<" "<<nazwa<<endl;}
      string w_nazwa() const {return nazwa;}
     
};
Pojazd pojazd;

class Vulture : public Pojazd
{
   public:
   Vulture()
   {
      nazwa="Vulture";
   }
};
Vulture vulture;

class Lotniskowiec : public Pojazd
{
   public:
   Lotniskowiec()
   {
      nazwa="Lotniskowiec";
   }
};
Lotniskowiec lotniskowiec;

class Tygrys : public Pojazd
{
   public:
   Tygrys()
   {
      nazwa="Tygrys";
   }
};
Tygrys tygrys;

int main()
{
    Pojazd* kontener[100];
   for(int i=0; i<3; i++ )
   {
      Pojazd* nowy_item = NULL;
      switch(i)
      {
         case 0:
            nowy_item=new Vulture();
            kontener[i]= nowy_item;
            kontener[i]->zmien_dlugosc_lufy();
            kontener[i]->dane();
            break;
         case 1:
            nowy_item=new Lotniskowiec();
            kontener[i]= nowy_item;
            kontener[i]->zmien_dlugosc_kadluba();
            kontener[i]->dane();
            break;
         case 2:
            nowy_item=new Tygrys();
            kontener[i]= nowy_item;
            kontener[i]->zmien_dlugosc_skrzydel();
            kontener[i]->dane();
            break;
      }
   }
   for(int i=0; i<3; i++ )
   {
      if(kontener[i]->w_nazwa()=="Vulture") cout<<kontener[i]->w_nazwa()<<" dlugosc skrzydel : "<<kontener[i]->w_dlugosc_lufy()<<endl;
      if(kontener[i]->w_nazwa()=="Lotniskowiec") cout<<kontener[i]->w_nazwa()<<" dlugosc kadluba : "<<kontener[i]->w_dlugosc_kadluba()<<endl;
      if(kontener[i]->w_nazwa()=="Tygrys") cout<<kontener[i]->w_nazwa()<<" dlugosc_lufy : "<<kontener[i]->w_dlugosc_skrzydel()<<endl;
   }
}

11
Projektowanie kodu / Odp: Kolizja dla wielu struktur
« dnia: Styczeń 24, 2015, 21:41:49 »
więc takie "cos" i "pokaz_to_cos" nie powinno być po prostu używane przez zewnętrzny kod na ile to możliwe
A jeśli takiego czegoś jest więcej dla czołgu np: szybkosc, dlugosc_lufy, grubosc_pancerza_przedniego itd.
Chyba że zależy jak to wszystko jest dziedziczone. Ale już miej więcej rozumiem jak ten kod powinien być zbudowany.

12
Projektowanie kodu / Odp: Kolizja dla wielu struktur
« dnia: Styczeń 24, 2015, 20:18:55 »
lethern ty mnie chyba nie zrozumiałeś.
Twój kod działa w 100% ale problem jest taki że jeżeli dodam do klasy czołg:
class Czolg : public Pojazd
{
        private:
            int cos;
        public:
                Czolg() : Pojazd( "Statek", 30 )
                {
                    cos=100;
                }
                int pokaz_to_cos()
                {
                   return cos;
                }
};
int cos, to gdy zrobię rzutowanie
Pojazd* nowy_item = NULL;
        nowy_item= new Czolg();
        kontener[0]= nowy_item;
        kontener[0]->wyswietl_opis();
        cout<<kontener[0]->pokaz_to_cos()<<endl;
to nie mam dostępu do "cos" jak i metody int pokaz_to_cos() które są  tylko przeznaczone dla czołgu.

13
Projektowanie kodu / Odp: Kolizja dla wielu struktur
« dnia: Styczeń 24, 2015, 18:26:08 »
Nie mam pojęcia jak to zrobić, do głowy przychodzi mi tylko mój własny wymyślony kontener który jak się dowiedziałem jest głupim pomysłem. Lub stworzyć zmienne w klasie pojazd osobne dla każdego potomka, ale to tez jest głupi pomysł bo wtedy mógłbym wszystkie te 4 klasy zastąpić 1 klasa i ta sama zasada działania będzie a nawet mniej kodu.

14
Projektowanie kodu / Odp: Kolizja dla wielu struktur
« dnia: Styczeń 24, 2015, 02:35:56 »
Czyli tak jak myślałem. też w podobny napisałem wcześniej kod ale bez wskaźników. Usunąłem go(myślałem że go źle napisałem) bo gdy dodałem zmienna prywatną do potomka czołg której nie posiadał pojazd to ta zmienna prywatna nie była brana pod uwagę i nie mogłem stworzyć czołgów z ta zmienną która miała mieć różną wartość dla każdego czołgu.
Ta zmienna była przeznaczona tylko dla czołgu. Jutro jeszcze na spokojnie sobie usiądę przed kodem i go przeanalizuje.

15
Projektowanie kodu / Odp: Kolizja dla wielu struktur
« dnia: Styczeń 24, 2015, 01:21:29 »
Czyli mam zrozumieć że klasa abstrakcyjna pojazd powinien być tablicą a potomki czołg, samolot,statek powinienem tak jak by przypisać do tablicy abstrakcyjnej pojazd ?

Strony: [1] 2 3