spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#ifndef CBOX_H_INCLUDED
#define CBOX_H_INCLUDED

#include "CEntity.h"

#define DROP_SPEED 100

//class CEntity;

class CBox:public CEntity
{
public:
    void gravity(/*CEntity *BoxEntity*/);
    void TypesLoop() const;
    CBox();
    ~CBox();
};

#endif // CBOX_H_INCLUDED

C-/C++-Quelltext

#include "CBox.h"

/*
bool CBox::OnLoop()
{
   AnimControl.OnAnimate();
   return 1;
}
*/

void CBox::gravity(/*CEntity *BoxEntity*/)
{
    if(true/*!(collision)*/) //Kollisionskontrolle noch aktivieren
    {
        /*
        if(DROP_SPEED <= drop_counter)
        {
                BoxEntity->pos.y ++;
                drop_counter = 0;
        }
        drop_counter ++;*/
    }
}

void CBox::TypesLoop() const
{

}

CBox::CBox()
{

}

CBox::~CBox()
{

}

C-/C++-Quelltext

#ifndef CENTITY_H_INCLUDED
#define CENTITY_H_INCLUDED

#include <SDL.h>
#include <vector>

#include "types.h"
#include "CAnimationControl.h"
#include "CSurface.h"

// Entity - Typen:
#define TYPE_BOX 1

class CEntity
{
public:
    static std::vector<CEntity*> EntityList;    // Liste der Entities

    position pos;   // Position
    int width; // Breite
    int height; // Höhe

    CEntity();
    virtual ~CEntity();

    //Animation
    int AnimState;  // Aktuelles Bild

    // Funktionen
    virtual bool OnLoad(std::string file,int Width, int Height, int MaxFrames); // Erstellen
    virtual void OnLoop();          // Refresh
    virtual void OnRender(SDL_Surface* Surf_Display,SDL_Surface* Surf_Background);       // Rendern
    virtual void OnCleanup();       // Löschen
    virtual void SetType(int newtype);
    virtual int GetType();

    virtual void TypesLoop() const;

private:
    SDL_Surface* Surf_Entity;   // Surface des Entities
    CAnimControl AnimControl;
    int type;
    position old_pos; // alte Position
};

#endif // CENTITY_H_INCLUDED

C-/C++-Quelltext

#include "CEntity.h"

std::vector<CEntity*> CEntity::EntityList;

CEntity::CEntity()
{
    Surf_Entity = NULL;

    pos.x = 0;
    pos.y = 0;

    width = 0;
    height = 0;
    AnimState = 0;
}

CEntity::~CEntity()
{

}

bool CEntity::OnLoad(std::string file, int Width, int Height, int MaxFrames)
{
    Surf_Entity = CSurface::load_image(file);
    this->width = Width;
    this->height = Height;
    AnimControl.SetFrameRate(24);
    if(Surf_Entity == NULL)
    {
        return false;
    }
    return true;
}

void CEntity::OnLoop()
{
    AnimControl.OnAnimate();
}

void CEntity::OnRender(SDL_Surface* Surf_Display,SDL_Surface* Surf_Background)
{
    if(Surf_Entity == NULL || Surf_Display == NULL) return;
    if((pos.x != old_pos.y)||(pos.y != old_pos.y))
    {
        CSurface::OnDraw(Surf_Display, Surf_Background, old_pos.x, old_pos.y, 0, 0, width, height);
        old_pos.x = pos.x;
        old_pos.y = pos.y;
    }
    CSurface::OnDraw(Surf_Display, Surf_Entity, pos.x, pos.y, AnimState * width, AnimControl.GetCurrentFrame() * height, width, height);
}

void CEntity::SetType(int newtype)
{
    type = newtype;
}
int CEntity::GetType()
{
    return type;
}

void TypesLoop()
{

}

void CEntity::OnCleanup()
{

}

C-/C++-Quelltext

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

#include "CHandler.h"

class CApp
{
private:

public:
    int OnExecute();
};

int CApp::OnExecute()
{
    std::cout << "---Start---\n";
    CHandler::NewBase();    // 0
    CHandler::NewChild();   // 1
    CHandler::NewBase();    // 2
    CHandler::NewBase();    // 3
    CHandler::NewChild();   // 4
    CHandler::NewChild();   // 5
    CHandler::NewChild();   // 6

    for(unsigned int i= 0; i < CBase::BaseList.size(); i++)
    {
        std::cout <<" -------" << i << "------- \n";
        CBase::BaseList[i]->output();
    }
    return 0;
}

int main()
{
    CApp theApp;
    return theApp.OnExecute();
}

C-/C++-Quelltext

#ifndef CBASE_H_INCLUDED
#define CBASE_H_INCLUDED

#include <iostream>
#include <vector>

class CBase
{
public:
    static std::vector<CBase*> BaseList;

    virtual void output();

    CBase();

private:

};

class CChild2: public CBase
{
public:
    void output()
    {
        std::cout << "Hi, I'm Child-class\n";
        ChildExtra();
    }
    void ChildExtra()
    {
        std::cout << "Child extra!\n";
    }
    CChild2()
    {

    }
private:

};

#endif // CBASE_H_INCLUDED

C-/C++-Quelltext

#include "CBase.h"

std::vector<CBase*> CBase::BaseList;

void CBase::output()
{
    std::cout << "Hi, I'm Base-class\n";
}

CBase::CBase()
{

}

C-/C++-Quelltext

#ifndef CCHILD_H_INCLUDED
#define CCHILD_H_INCLUDED

#include <iostream>

/*
class CChild: public CBase
{
public:
    void output();
    void ChildExtra();
    CChild();
private:

};
*/
#endif // CCHILD_H_INCLUDED

C-/C++-Quelltext

#include "CChild.h"

/*
void CChild::output()
{
    std::cout << "Hi, I'm Child-class\n";
    ChildExtra();
}

void CChild::ChildExtra()
{
    std::cout << "Child extra!\n";
}

CChild::CChild()
{

}
*/

C-/C++-Quelltext

#ifndef CHANDLER_H_INCLUDED
#define CHANDLER_H_INCLUDED

#include "CBase.h"

class CHandler
{
public:
    static void NewBase();
    static void NewChild();
};

#endif // CHANDLER_H_INCLUDED

C-/C++-Quelltext

#include "CHandler.h"

void CHandler::NewBase()
{
    CBase *object = new CBase;
    CBase::BaseList.push_back(object);
}

void CHandler::NewChild()
{
    CBase *object = new CChild2;
    CBase::BaseList.push_back(object);
}