Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

Projekt Wieloplikowy, Obiekty Globalne, Błędy Konsolidacji

Ostatnio zmodyfikowano 2013-11-01 17:37
Autor Wiadomość
rosoladm
Temat założony przez niniejszego użytkownika
Projekt Wieloplikowy, Obiekty Globalne, Błędy Konsolidacji
» 2013-11-01 10:30:07
Witam,

Tworze gre wieloplikową, to jest dopiero początek platformy, dlateog zależy mi żeby napisać ją w kilku plikach ( będzie dużo edycji )
Podczas konsolidacji pojawia się problem ( załączony niżej log ), jak widzę jest to problem zmiennych, a raczej obiektów globalnych, poniżej zamieszczam kod wszystkich plików.


Z góry dziękuję za pomoc,
Pozdrawiam,
Krystian



g++  -c fun/main.cpp -o appo/main.o
g++ -c fun/fun1.cpp -o appo/fun1.o
g++ -c fun/maszt.cpp -o appo/maszt.o
g++ -c fun/plansza.cpp -o appo/plansza.o
g++ -c fun/statek.cpp -o appo/statek.o
g++ appo/main.o appo/fun1.o appo/maszt.o appo/plansza.o appo/statek.o -o gra
appo/fun1.o:(.bss+0x0): multiple definition of `Orzel'
appo/main.o:(.bss+0x0): first defined here
appo/fun1.o:(.bss+0x20): multiple definition of `Jastrzab'
appo/main.o:(.bss+0x20): first defined here
appo/fun1.o:(.bss+0x40): multiple definition of `Hawk'
appo/main.o:(.bss+0x40): first defined here
appo/fun1.o:(.bss+0x5c): multiple definition of `Eagle'
appo/main.o:(.bss+0x5c): first defined here
appo/maszt.o:(.bss+0x0): multiple definition of `Orzel'
appo/main.o:(.bss+0x0): first defined here
appo/maszt.o:(.bss+0x20): multiple definition of `Jastrzab'
appo/main.o:(.bss+0x20): first defined here
appo/maszt.o:(.bss+0x40): multiple definition of `Hawk'
appo/main.o:(.bss+0x40): first defined here
appo/maszt.o:(.bss+0x5c): multiple definition of `Eagle'
appo/main.o:(.bss+0x5c): first defined here
appo/plansza.o:(.bss+0x0): multiple definition of `Orzel'
appo/main.o:(.bss+0x0): first defined here
appo/plansza.o:(.bss+0x20): multiple definition of `Jastrzab'
appo/main.o:(.bss+0x20): first defined here
appo/plansza.o:(.bss+0x40): multiple definition of `Hawk'
appo/main.o:(.bss+0x40): first defined here
appo/plansza.o:(.bss+0x5c): multiple definition of `Eagle'
appo/main.o:(.bss+0x5c): first defined here
appo/statek.o:(.bss+0x0): multiple definition of `Orzel'
appo/main.o:(.bss+0x0): first defined here
appo/statek.o:(.bss+0x20): multiple definition of `Jastrzab'
appo/main.o:(.bss+0x20): first defined here
appo/statek.o:(.bss+0x40): multiple definition of `Hawk'
appo/main.o:(.bss+0x40): first defined here
appo/statek.o:(.bss+0x5c): multiple definition of `Eagle'
appo/main.o:(.bss+0x5c): first defined here
collect2: ld returned 1 exit status
make: *** [gra] Błąd 1


funkcje.h

C/C++
#ifndef _FUNKCJE_H
#define _FUNKCJE_H

#include <iostream>
#include <iomanip> // setw()
#include <cstdlib> // srand()
#include <ctime> // time()

using namespace std;



class plansza;
class maszt;
class statek;
class pancernik;
class torpedowiec;

//*********************************************************************************************************************************************************

// ./fun/plansza.cpp

class plansza
{
public:
    maszt *** wsk; // wskaznik do wskaznika na wskaznik :P
    plansza();
    ~plansza();
    void wyswietl();
};

//*********************************************************************************************************************************************************

// ./fun/maszt.cpp

class maszt // elementarna klasa
{
public:
    char stan;
    int typ; // 0 - nieostrzelany, 1 - ostrzelany, 2 - zatopiony, 3 - puste, 4 - pudlo
    maszt()
        : stan( '.' )
        , typ( 3 )
    { } // konstruktor, na poczatku nie ma zadnych stakow czyli maszty sa puste
    void wyswietl();
};

//*********************************************************************************************************************************************************

// ./fun/statek.cpp

class statek // do polimorfizmu, klasa bazowa klasy pancernik (4-masztowiec) i torpedowiec (3-masztowiec)
{
public:
    virtual bool CzyPlywam() { return true; };
    virtual void buduj( int x, int y, plansza & NazwaPlanszy, bool pion ) { };
};

class pancernik
    : public statek // klasa czteromasztowcow
{
public:
    int iks, igrek; // wspolrzedne poczatku statku
    bool pionowy; // zmienna okreslajaca czy statek jest polozony pionowo czy poziomo
    maszt * tablica[ 4 ]; // tablica 4 wskaznikow do obiektow typu maszt - czesci skladowych czteromasztowca
    void buduj( int x, int y, plansza & NazwaPlanszy, bool pion );
    bool CzyPlywam();
};

class torpedowiec
    : public statek // klasa trojmasztowcow
{
public:
    int iks, igrek; // wspolrzedne poczatku statku
    bool pionowy; // zmienna okreslajaca czy statek jest polozony pionowo czy poziomo
    maszt * tablica[ 3 ]; // tablica 3 wskaznikow do obiektow typu maszt - czesci skladowych trojmasztowca
    void buduj( int x, int y, plansza & NazwaPlanszy, bool pion );
    bool CzyPlywam();
};

void Ruch( plansza & NazwaPlanszy, pancernik & okret, torpedowiec & torpeda );
int IlePlywa( int wyswietl );
#endif


zmienne.h

C/C++
#ifndef _ZMIENNE_H
#define _ZMIENNE_H
#include "funkcje.h"

pancernik Orzel, Jastrzab; // dwa cztermosztowce
torpedowiec Hawk, Eagle; // dwa trojmasztowce
const bool Linux = true;
const bool Testowanie = false; // zmien na false, jak nie chcesz widziec, gdzie sa statki
#endif





main.cpp:

C/C++
#include "../lib/funkcje.h"
#include "../lib/zmienne.h"


int main()
{
    extern pancernik Orzel, Jastrzab; // dwa cztermosztowce
    extern torpedowiec Hawk, Eagle; // dwa trojmasztowce
   
    srand( time( NULL ) );
    plansza statki;
    bool pion = rand() % 2;
    // losowe ustawienie dwoch 4-masztowcow:
    statek * wsk =& Orzel;
    ( * wsk ).buduj(( pion ) ?( rand() % 15 ) + 1
        :( rand() % 12 ) + 1
        ,( pion ) ?( rand() % 12 ) + 1
        :( rand() % 15 ) + 1
        , statki
        , pion ); // polimorfizm
    pion = rand() % 2; // losowanie pion/poziom, powtorne bo by byly oba pion/poziom zawsze
    int iks_, igrek_; //
    do //
    { // eliminowanie kolizji (zeby statki sie nie krzyzowaly)
        iks_ =( pion ) ?( rand() % 15 ) + 1
            :( rand() % 12 ) + 1; // losujemy wspolrzedne dopoty dopoki nie beda odpowiednie
        igrek_ =( pion ) ?( rand() % 12 ) + 1
            :( rand() % 15 ) + 1; //
    } while(( abs( iks_ - Orzel.iks ) < 4 ) ||( abs( igrek_ - Orzel.igrek ) < 4 ) ); //
   
    wsk =& Jastrzab;
    ( * wsk ).buduj( iks_, igrek_, statki, pion );
    pion = rand() % 2;
    do //
    { // eliminowanie kolizji (zeby statki sie nie krzyzowaly)
        iks_ =( pion ) ?( rand() % 15 ) + 1
            :( rand() % 12 ) + 1; // losujemy wspolrzedne dopoty dopoki nie beda odpowiednie
        igrek_ =( pion ) ?( rand() % 12 ) + 1
            :( rand() % 15 ) + 1; //
    } while(( abs( iks_ - Orzel.iks ) < 3 || abs( iks_ - Jastrzab.iks ) < 3 ) ||( abs( igrek_ - Orzel.igrek ) < 3 || abs( igrek_ - Jastrzab.igrek ) < 3 ) );
   
    wsk =& Hawk;
    ( * wsk ).buduj( iks_, igrek_, statki, pion );
    pion = rand() % 2;
    do //
    { // eliminowanie kolizji (zeby statki sie nie krzyzowaly)
        iks_ =( pion ) ?( rand() % 15 ) + 1
            :( rand() % 12 ) + 1; //
        igrek_ =( pion ) ?( rand() % 12 ) + 1
            :( rand() % 15 ) + 1; //
    } while(( abs( iks_ - Orzel.iks ) < 3 &&( abs( igrek_ - Orzel.igrek ) < 3 ) ||( abs( iks_ - Jastrzab.iks ) < 3 && abs( igrek_ - Jastrzab.igrek ) < 3 ) ||( abs( iks_ - Hawk.iks ) < 2 ) && abs( igrek_ - Hawk.igrek ) < 3 ) );
   
    wsk =& Eagle;
    ( * wsk ).buduj( iks_, igrek_, statki, pion );
    statki.wyswietl();
    int ile = 4; // na poczatku plywaja 4 statki
    int IloscRuchow = 0; // zmienna do liczenia ruchow
    while( IlePlywa( 0 ) )
    {
        IlePlywa( 1 );
        Ruch( statki, Orzel, Hawk );
        ++IloscRuchow;
        IlePlywa( 1 ); // wyswietlenie ilosci plywajacych (niezatopionych statkow)
        if( IlePlywa( 0 ) ) // jezeli plywa jeszcze jakis statek
        {
            Ruch( statki, Jastrzab, Eagle );
            ++IloscRuchow;
        }
    }
    statki.wyswietl();
    cout << "Brawo! Wszystkie zatopione!\n"
    << "Ilosc ruchow: " << IloscRuchow << "\n";
    return 0;
}


fun1.cpp

C/C++
#include "../lib/funkcje.h"
#include "../lib/zmienne.h"

extern pancernik Orzel, Jastrzab; // dwa cztermosztowce
extern torpedowiec Hawk, Eagle; // dwa trojmasztowce


int IlePlywa( int wyswietl ) // zwraca ilosc plywajacych statkow, wyswietl=0 - nie wyswietla, 1 - wyswietla
{
    int ile = 0; // zerujemy licznik bo zaraz sprawdzimy ile w danej chwili aktualnie plywa
    //(Orzel.CzyPlywam()) ? ile++ :ile;      //
    //(Jastrzab.CzyPlywam()) ? ile++ :ile;   // sprawdzenie (nie polimorfizm)
    //(Hawk.CzyPlywam()) ? ile++ :ile;      //
    //(Eagle.CzyPlywam()) ? ile++ :ile;      //
   
    //statek *wsk;                                     //
    //(*(wsk=&Orzel)).CzyPlywam() ? ile++ : ile;       //
    //(*(wsk=&Jastrzab)).CzyPlywam() ? ile++ : ile;    // sprawdzenie (polimorfizm)
    //(*(wsk=&Hawk)).CzyPlywam() ? ile++ : ile;        //        dluzsza wersja
    //(*(wsk=&Eagle)).CzyPlywam() ? ile++ : ile;       //
   
    statek * wsk[ 4 ] = { & Orzel, & Jastrzab, & Hawk, & Eagle }; //
    for( int i = 0; i < 4; ++i ) // j.w.- krotsza wersja
         if(( *( wsk[ i ] ) ).CzyPlywam() ) ile++; //
   
    if( wyswietl ) cout << "Plywa jeszcze statkow: " << ile << endl;
   
    return ile;
}

void Ruch( plansza & NazwaPlanszy, pancernik & okret, torpedowiec & torpeda )
{
    bool CzyZatopiony = false;
    int x, y;
    do // wczytywanie danych + zabezpieczenie przed podaniem zlych wspolrzednych
    {
        cout << "Podaj x: ";
        cin >> x;
        cout << "Podaj y: ";
        cin >> y;
        if( x > 16 || y > 16 || x < 0 || y < 0 )
        {
            if( !x || !y ) exit( 0 ); // zero -> konczymy program
           
            NazwaPlanszy.wyswietl();
            IlePlywa( 1 );
            cout << "Zle wspolrzedne, podaj jeszcze raz!\n";
            if( x == 1337 ) // cheat, jak wpiszemy pod x 1337, program pokazuje wszystkie statki ;)
            {
                Testowanie == true;
                NazwaPlanszy.wyswietl();
            }
        }
    } while( x > 16 || y > 16 || x < 0 || y < 0 );
   
    if( x == 0 || y == 0 ) exit( 0 ); // na wcisniecie zera program sie konczy
   
    char temp = NazwaPlanszy.wsk[ y - 1 ][ x - 1 ]->stan;
    switch( temp )
    {
    case '.':
        NazwaPlanszy.wsk[ y - 1 ][ x - 1 ]->stan = char( 219 ); // symbol ASCII zapelnionego prostokatu - pod Linuxem moze nie wyswietlac prawidlowo
        NazwaPlanszy.wsk[ y - 1 ][ x - 1 ]->typ = 4;
        break;
    case 'X':
    case 'o':
        NazwaPlanszy.wsk[ y - 1 ][ x - 1 ]->stan = 'o';
        NazwaPlanszy.wsk[ y - 1 ][ x - 1 ]->typ = 1;
        break;
    }
    statek * wsk;
    wsk =& okret;
    if( okret.CzyPlywam() == false ) // jak czteromasztowiec nie plywa, to znaczy ze tonie, zmieniamy jego znaki na "/" i typ masztow na zatopione
    {
        for( int i = 1; i <= 4; i++ )
        {
            ( okret.pionowy ) ? NazwaPlanszy.wsk[ okret.igrek + 4 - i ][ okret.iks ]->stan = '\\'
                : NazwaPlanszy.wsk[ okret.igrek ][ okret.iks + 4 - i ]->stan = '\\';
            ( okret.pionowy ) ? NazwaPlanszy.wsk[ okret.igrek + 4 - i ][ okret.iks ]->typ = 2
                : NazwaPlanszy.wsk[ okret.igrek ][ okret.iks + 4 - i ]->typ = 2;
        }
    }
    if( torpeda.CzyPlywam() == false ) // j.w. tyle ze trojmasztowiec
    {
        for( int i = 1; i <= 3; i++ )
        {
            ( torpeda.pionowy ) ? NazwaPlanszy.wsk[ torpeda.igrek + 3 - i ][ torpeda.iks ]->stan = '\\'
                : NazwaPlanszy.wsk[ torpeda.igrek ][ torpeda.iks + 3 - i ]->stan = '\\';
            ( torpeda.pionowy ) ? NazwaPlanszy.wsk[ torpeda.igrek + 3 - i ][ torpeda.iks ]->typ = 2
                : NazwaPlanszy.wsk[ torpeda.igrek ][ torpeda.iks + 3 - i ]->typ = 2;
        }
    }
    NazwaPlanszy.wyswietl(); // odswiezamy plansze po kazdym ruchu
}


maszt.cpp

C/C++
#include "../lib/funkcje.h"
#include "../lib/zmienne.h"

extern pancernik Orzel, Jastrzab; // dwa cztermosztowce
extern torpedowiec Hawk, Eagle; // dwa trojmasztowce


void maszt::wyswietl()
{
    if( Testowanie ) // jak testujemy to pokazujemy statki od razu
         cout << stan << "  ";
    else // jak gramy to statki sa ukryte
        ( stan == 'X' ) ? cout << ".  "
        : cout << stan << "  ";
   
}


plansza.cpp

C/C++
#include "../lib/funkcje.h"
#include "../lib/zmienne.h"


extern pancernik Orzel, Jastrzab; // dwa cztermosztowce
extern torpedowiec Hawk, Eagle; // dwa trojmasztowce


plansza::plansza() // konstruktor planszy
{
    wsk = new maszt **[ 18 ]; // plansza jest 2-wymiarowa tablica wskaznikow do masztow
    for( int i = 0; i < 18; i++ ) // rozmiar 18 a plansza 16x16, zeby nie bylo przekroczenia zakresu przy losowym ustawianiu statkow
    { // (pionowy statek moglby sie zaczac np w y=15 i mamy przekroczenie zakresu)
        wsk[ i ] = new maszt *[ 18 ];
        for( int j = 0; j < 18; j++ )
        {
            wsk[ i ][ j ] = new maszt(); // pojedynczy maszt
        }
    }
}

plansza::~plansza() // destruktor planszy, wykonuje sie kiedy plansza jest niszczona czyli po zakonczeniu gry
{
    cout << "Plansza kaput!\n"; // do testowania zadzialania destruktora
    for( int i = 0; i < 18; i++ ) // zwolnienie zaalokowanej pamieci
    {
        for( int j = 0; j < 18; j++ )
        {
            delete wsk[ i ][ j ]; // niszczymy pojedyncze maszty
        }
        delete wsk[ i ]; // ... tablice masztow
    }
    delete wsk; // ... i tablice tablic
    if( !Linux ) system( "pause" );
   
}

void plansza::wyswietl() // wyswietlanie planszy
{
    if( Linux ) system( "clear" ); // linux
    else system( "cls" ); // windows
   
    for( int i = 1; i <= 16; i++ ) // wyswietlenie 16 wierszy
    {
        cout << setw( 2 ) << i << " "; // ladny rowny odstep
        for( int j = 1; j <= 16; j++ )
             wsk[ i - 1 ][ j - 1 ]->wyswietl(); // wyswietlanie 16 kolumn masztow
       
        switch( i )
        {
        case 1:
            cout << "Legenda: ";
            break;
        case 2:
            cout << " .  Pole puste nieostrzelane";
            break;
        case 3:
            cout << " /  Maszt zatopiony";
            break;
        case 4:
            cout << " o  Maszt ostrzelany";
            break;
        case 5:
            cout << " " << char( 219 ) << "  Pudlo";
            break;
        case 6:
            cout << "    x=1337 - cheat ;-)";
            break;
        case 8:
            cout << " 0 - wyjscie z programu";
            break;
        }
        cout << endl;
    }
    cout << "   1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16\n\n";
}


statek.cpp

C/C++
#include "../lib/funkcje.h"
#include "../lib/zmienne.h"

extern pancernik Orzel, Jastrzab; // dwa cztermosztowce
extern torpedowiec Hawk, Eagle; // dwa trojmasztowce


void pancernik::buduj( int x, int y, plansza & NazwaPlanszy, bool pion ) // pion=1 statek pionowo, pion=0 statek poziomo
{
    iks = x; // do dostepu z zewnatrz - musimy potem znac wspolrzedne statku
    igrek = y; // j.w.
    pionowy = pion; // j.w.
    for( int i = 0; i < 4; i++ )
    {
        ( pion ) ? tablica[ i ] = NazwaPlanszy.wsk[ y + i ][ x ]
            : tablica[ i ] = NazwaPlanszy.wsk[ y ][ x + i ]; // przypisanie masztow do statku
        ( pion ) ? NazwaPlanszy.wsk[ y + i ][ x ]->stan = 'X'
            : NazwaPlanszy.wsk[ y ][ x + i ]->stan = 'X'; // i ich znakow - z poczatku wszystkie dobre
        ( pion ) ? NazwaPlanszy.wsk[ y + i ][ x ]->typ = 0
            : NazwaPlanszy.wsk[ y ][ x + i ]->typ = 0; // typ - tez dobre
    }
}

bool pancernik::CzyPlywam()
{
    int Good = 4;
    for( int i = 0; i < 4; i++ )
    {
        if( tablica[ i ]->typ == 1 || tablica[ i ]->typ == 2 ) // jezeli maszt ostrzelany lub zatopiony
             Good--; // to zmniejszamy ilosc dobrych masztow w statku
       
    }
    if( Good > 0 ) return true; // jezeli ilosc masztow dobrych >0 to statek jeszcze plywa
   
    return false; // w przeciwnym wypadku jest zatopiony
}

void torpedowiec::buduj( int x, int y, plansza & NazwaPlanszy, bool pion ) // pion=1 statek pionowo, pion=0 statek poziomo
{
    iks = x; // do dostepu z zewnatrz
    igrek = y; // j.w.
    pionowy = pion; // j.w.
    for( int i = 0; i < 3; i++ )
    {
        ( pion ) ? tablica[ i ] = NazwaPlanszy.wsk[ y + i ][ x ]
            : tablica[ i ] = NazwaPlanszy.wsk[ y ][ x + i ]; // przypisanie statkowi odpowiednich masztow
        ( pion ) ? NazwaPlanszy.wsk[ y + i ][ x ]->typ = 0
            : NazwaPlanszy.wsk[ y ][ x + i ]->typ = 0; // i nadanie im wartosci (nieostrzelane)
        ( pion ) ? NazwaPlanszy.wsk[ y + i ][ x ]->stan = 'X'
            : NazwaPlanszy.wsk[ y ][ x + i ]->stan = 'X';
    }
}

bool torpedowiec::CzyPlywam()
{
    int Good = 3;
    for( int i = 0; i < 3; i++ )
    {
        if( tablica[ i ]->typ == 1 || tablica[ i ]->typ == 2 ) // jezeli maszt ostrzelany lub zatopiony
             Good--; // to zmniejszamy ilosc dobrych masztow w statku
       
    }
    if( Good > 0 ) return true;
   
    return false;
}
P-95009
pekfos
» 2013-11-01 17:37:55
W nagłówkach muszą być deklaracje, a nie definicje zmiennych.
P-95025
« 1 »
  Strona 1 z 1