spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

class Tier {
virtual void test() = 0;
};
class DummTier: public Tier {
    int leben;
    DummTier() : leben(100) {}

    void test() {
        std::cout << leben << std::endl;
    }
};

class SchlauTier: public Tier {
    int hirn;
    Tier* tier;

    SchlauTier(Tier* _tier) :  hirn(10), tier(_tier) {}

    void test() {
        std::cout << tier->leben << ", " << hirn << std::endl;
    }
};

C-/C++-Quelltext

Tier* tier = new Tier();

//[...] Mutation


SuperTier super = new SuperTier();
super->setLebenspunkte(tier->getLebenspunkte());
//[...] noch andere Variablen

delete tier;

Quellcode

class RunBehaviour 
{
public:
    virtual void run() = 0;
};

Quellcode

class Animal
{
private:
   RunBehaviour *rb;

public:
    Animal() 
    {
       rb = new DefaultRunBehaviour(); 
    }

    void run() 
    {
        rb->run();
    }

    void setRunBehaviour(RunBevhaviour *rb) { this->rb = rb; }
};

C-/C++-Quelltext

#include<iostream>

class Tier
{
protected:
    int defence;
public:
    Tier():defence(60){}
    virtual ~Tier(){}
    int getDefence(){return defence;}
    void setDefence(int defence){this->defence = defence;}
    void mutation(Tier* ziel)
    {
        ziel->setDefence(this->defence);
    }
};

class SuperTier : public Tier
{
protected:
    int attack;
public:
    SuperTier():attack(70){}
    ~SuperTier(){}
    int getAttack(){return attack;}
    void setAttack(int attack){this->attack = attack;}
    void mutation(SuperTier* ziel)
    {
        ziel->setDefence(this->defence);
        ziel->setAttack(this->attack);
    }
};

class SuperSuperTier : public SuperTier
{
protected:
    int specialeAttack;
public:
    SuperSuperTier():specialeAttack(130){}
    ~SuperSuperTier(){}
    int getSpecialeAttack(){return specialeAttack;}
    void setSpecialeAttack(int specialeAttack){this->specialeAttack = specialeAttack;}
    void mutation(SuperSuperTier* ziel)
    {
        ziel->setDefence(this->defence);
        ziel->setAttack(this->attack);
        ziel->setSpecialeAttack(this->specialeAttack);
    }
};

class SuperSuperTierV2 : public SuperTier
{
protected:
    int specialeAttack;
public:
    SuperSuperTierV2():specialeAttack(140){}
    ~SuperSuperTierV2(){}
    int getSpecialeAttack(){return specialeAttack;}
    void setSpecialeAttack(int specialeAttack){this->specialeAttack = specialeAttack;}
    void mutation(SuperSuperTierV2* ziel)
    {
        ziel->setDefence(this->defence-10);
        ziel->setAttack(this->attack+10);
        ziel->setSpecialeAttack(this->specialeAttack);
    }
};

class EndTier : public SuperSuperTier
{
private:
    int specialeDefence;
public:
    EndTier():specialeDefence(150){}
    ~EndTier(){}
    void print()
    {
        std::cout<<this->defence<<std::endl;
        std::cout<<this->attack<<std::endl;
        std::cout<<this->specialeAttack<<std::endl;
        std::cout<<this->specialeDefence<<std::endl;
    }
};

class EndTierV2 : public SuperSuperTierV2
{
private:
    int specialeDefence;
public:
    EndTierV2():specialeDefence(140){}
    ~EndTierV2(){}
    void print()
    {
        std::cout<<this->defence<<std::endl;
        std::cout<<this->attack<<std::endl;
        std::cout<<this->specialeAttack<<std::endl;
        std::cout<<this->specialeDefence<<std::endl;
    }
};

int main()
{
    Tier* tier = new Tier();

    //Mutation


    SuperTier* sutier = new SuperTier();
    tier->mutation(sutier);
    delete tier;

    //weiere Mutation


    SuperSuperTier* susutier = new SuperSuperTier();
    sutier->mutation(susutier);
    delete sutier;

    //letzte Mutation

    EndTier* etier = new EndTier();
    susutier->mutation(etier);
    delete susutier;

    etier->print();
    delete etier;

    //anderer Mutationsstrang


    Tier* tierv2 = new Tier();

    //Mutation


    SuperTier* sutierv2 = new SuperTier();
    tierv2->mutation(sutierv2);
    delete tierv2;

    //weiere Mutation


    SuperSuperTierV2* susutierv2 = new SuperSuperTierV2();
    sutierv2->mutation(susutierv2);
    delete sutierv2;

    //letzte Mutation

    EndTierV2* etierv2 = new EndTierV2();
    susutierv2->mutation(etierv2);
    delete susutierv2;

    etierv2->print();
    delete etierv2;

    return 1;
}

C-/C++-Quelltext

class IBehavior
{
public:
    virtual void Execute() = 0;
};


class Creature;
class CreatureMutator;

class IMutator
{
    friend class CreatureMutator;

public:
    virtual void Mutate( Creature* creature )    = 0;

private:
    virtual void NextMutator( CreatureMutator* mutator ) = 0;
};

class EatBehaviorDefault : public IBehavior
{
public:
    void Execute()
    {
        printf( "...\n" );
    }
};

class EatBehaviorCow : public IBehavior
{
public:
    void Execute()
    {
        printf( "... isst Grass\n" );
    }
};

class EatBehaviorSheep : public IBehavior
{
public:
    void Execute()
    {
        printf( "... isst Grass\n" );
    }
};

class EatBehaviorPig : public IBehavior
{
public:
    void Execute()
    {
        printf( "... isst Trueffel und Abfaelle\n" );
    }
};

class EatBehaviorChicken : public IBehavior
{
public:
    int x;
    EatBehaviorChicken( int value ) : x( value )
    {
    }

    void Execute()
    {
        printf( "... isst %d Koerner\n", x );
    }
};

enum EBehaviorAction
{
    BEHAVIOR_EAT = 0
    // weitere

};

class Creature
{

public:
    typedef IBehavior* BehaviorPtr;
    typedef std::map< EBehaviorAction, std::vector< BehaviorPtr > > BehaviorList;

    Creature()
    {
    }

    ~Creature()
    {
        // ggf aufräumen etcpp...

    }

    void PushBehavior( EBehaviorAction action, BehaviorPtr behavior )
    {
        // hier ggf noch prüfen ob _dieser_ verhaltenstyp bereits vorhanden

        m_actionMap[ action ].push_back( behavior );
    }

    void RemoveBehavior( EBehaviorAction action, BehaviorPtr behavior )
    {
        // TODO: implementieren

    }

    void ExecuteBehavior( EBehaviorAction action ) const
    {
        BehaviorList::const_iterator it = m_actionMap.find( action );

        if ( it != m_actionMap.end() )
        {
            const std::vector< IBehavior* >& tmp = ( *it ).second;
            std::for_each( tmp.begin(), tmp.end(), std::mem_fun( &IBehavior::Execute )  );
        }
    }

private:
    BehaviorList m_actionMap;
};

class CreatureMutator
{
private:
    IMutator* m_pMutationRule;   // evtl auch liste von mutatoren


public:
    CreatureMutator() : m_pMutationRule( NULL )
    {
    }

    void NextStage( Creature* creature )
    {
        if ( !m_pMutationRule )
            return;

        m_pMutationRule->Mutate( creature );
        m_pMutationRule->NextMutator( this );
    }
};