[게임알고리즘] 3-3강 링크 리스트

3-2강에서 구현된 링크 리스트를 활용해서,

- 링크 리스트 객체에 몬스터들을 추가하고, 객체가 파괴될때 모든 몬스터가 파괴됨.

- 추가된 몬스터는 2-1강에서 학습한 Sort 구조체로 정렬.

#include "NodeMgt.h"
#include "Sort.h"
 
#include <time.h>
 
struct Monster
{
    char* name;
    int ap, dp, y;
    Monster(const char* n)
    {
        char* t = new char[strlen(n) + 1];
        strcpy(t, n);
        name = t;
        
        y = rand() % 1080;
    }
    
    virtual ~Monster()
    {
        printf("Monster(%s)\n", name);
        delete name;
    }
    
    virtual void paint(float dt) = 0;
};
 
struct Dog : Monster
{
    Dog(const char* n) : Monster(n) { }
    virtual void paint(float dt)
    {
        printf("Dog::paint(%d)\n", y);
    }
};
 
struct Cat : Monster
{
    Cat(const char* n) : Monster(n) { }
    virtual void paint(float dt)
    {
        printf("Cat::paint(%d)\n", y);
    }
};
 
struct Monkey : Monster
{
    Monkey(const char* n) : Monster(n) { }
    virtual void paint(float dt)
    {
        printf("Monkey::paint(%d)\n", y);
    }
};
 
void cbMonster(void* data)
{
    Monster* m = (Monster*)data;
    delete m;
};
 
int main() {
 
    // load
    srand(time(NULL));
    Monster** monster = new Monster*[3];
    monster[0] = new Dog("DSU");
    monster[1] = new Cat("Me");
    monster[2] = new Monkey("You");
    
    NodeMgt* monsterList = new NodeMgt(cbMonster);
    for(int i=0; i<3; i++)
        monsterList->add(monster[i]);
 
    Sort s;
    
    // loop
    //for(int i=0; i<monsterList.count; i++)
    //    monsterList->paint(0.0f);
    for(int i=0; i<monsterList->count; i++)
    {
        Monster* m = (Monster*)monsterList->at(i);
        s.add( m, m->y );
    }
    s.update();
    for(int i=0; i<monsterList->count; i++)
    {
        Monster* m = (Monster*)s.get(i);
        m->paint(0.0f);
    }
 
    // free
    delete monsterList;
 
    return 0;
}
 

 

 

온라인 컴파일에서 바로 실행해볼 수 있는 코드

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
 
// =================================================
// Sort.h
// =================================================
struct Data {
    void* data;
    float y;
};
 
struct Sort
{
    Sort(int max = 300);
    virtual ~Sort();
    
    void init();
    void add(void* data, float y);
    void* get(int index);
    void update();
    
    Data* data;
    int num;
};
 
// =================================================
// NodeMgt.h
// =================================================
struct Node
{
    void* data;
    Node* prev;
};
 
typedef void (*MethodNodeMgt)(void* data);
 
struct NodeMgt
{
    Node* last;
    int count;
    MethodNodeMgt method;
    
    NodeMgt(MethodNodeMgt m);
    virtual ~NodeMgt();
    
    void add(void* data);
    void add(int index, void* data);
    
    void del(int index);
    bool del_(void* data);
    void del(void* data);
    void delAll();
    
    void* at(int index);
};
 
// =================================================
// Main.cpp
// =================================================
struct Monster
{
    char* name;
    int ap, dp, y;
    Monster(const char* n)
    {
        char* t = new char[strlen(n) + 1];
        strcpy(t, n);
        name = t;
        
        y = rand() % 1080;
    }
    
    virtual ~Monster()
    {
        printf("Monster(%s)\n", name);
        delete name;
    }
    
    virtual void paint(float dt) = 0;
};
 
struct Dog : Monster
{
    Dog(const char* n) : Monster(n) { }
    virtual void paint(float dt)
    {
        printf("Dog::paint(%d)\n", y);
    }
};
 
struct Cat : Monster
{
    Cat(const char* n) : Monster(n) { }
    virtual void paint(float dt)
    {
        printf("Cat::paint(%d)\n", y);
    }
};
 
struct Monkey : Monster
{
    Monkey(const char* n) : Monster(n) { }
    virtual void paint(float dt)
    {
        printf("Monkey::paint(%d)\n", y);
    }
};
 
void cbMonster(void* data)
{
    Monster* m = (Monster*)data;
    delete m;
};
 
int main() {
 
    // load
    srand(time(NULL));
    Monster** monster = new Monster*[3];
    monster[0] = new Dog("DSU");
    monster[1] = new Cat("Me");
    monster[2] = new Monkey("You");
    
    NodeMgt* monsterList = new NodeMgt(cbMonster);
    for(int i=0; i<3; i++)
        monsterList->add(monster[i]);
 
    Sort s;
    
    // loop
    //for(int i=0; i<monsterList.count; i++)
    //    monsterList->paint(0.0f);
    for(int i=0; i<monsterList->count; i++)
    {
        Monster* m = (Monster*)monsterList->at(i);
        s.add( m, m->y );
    }
    s.update();
    for(int i=0; i<monsterList->count; i++)
    {
        Monster* m = (Monster*)s.get(i);
        m->paint(0.0f);
    }
 
    // free
    delete monsterList;
 
    return 0;
}
 
// =================================================
// Sort.cpp
// =================================================
Sort::Sort(int max)
{
    data = new Data[max];
    num = 0;
}
Sort::~Sort()
{
    delete data;
}
void Sort::init()
{
    num = 0;
}
void Sort::add(void* data_, float y)
{
    Data* d = &data[num];
    num++;
    
    d->data = data_;
    d->y = y;
}
void* Sort::get(int index)
{
    return data[index].data;    
}
void Sort::update()
{
    int k = num-1;
    for(int i=0; i<k; i++)
    {
        for(int j=1+i; j<num; j++)
        {
            if( data[i].y > data[j].y )
            {
                Data t = data[i];
                data[i] = data[j];
                data[j] = t;
            }
        }
    }
}
 
// =================================================
// NodeMgt.cpp
// =================================================
NodeMgt::NodeMgt(MethodNodeMgt m)
{
    last = NULL;
    count = 0;
    method = m;
}
 
NodeMgt::~NodeMgt()
{
    delAll();
}
 
void NodeMgt::add(void* data)
{
    Node* n = new Node;
    n->data = data;
    n->prev = last;
    
    last = n;
    count++;
}
    
void NodeMgt::add(int index, void* data)
{
    int i = count - 1;
    if( index==i )
    {
        add(data);
        return;
    }
    for(Node* p = last; p; p = p->prev, i--)
    {
        if(i==index)
        {
            Node* n = new Node;
            n->data = data;
            n->prev = p->prev;
            
            p->prev = n;
            count++;
            return;
        }
    }
    printf("failed to insert node\n");
}
    
void NodeMgt::del(int index)
{
    int i = count - 1;
    for(Node* p = last,* back = NULL; p; 
        back = p, p = p->prev, i--)
    {
        if(i==index)
        {
            if( back )
                back->prev = p->prev;
            else// if( last==NULL )
                last = p->prev;
            if( method )
                method(p->data);
            delete p;
            count--;
            return;
        }
    }
}
 
#if 0
 
bool NodeMgt::del_(void* data)
{
    for(Node* p = last, * back = NULL; p;
        back = p, p = p->prev)
    {
        if( p->data==data )
        {
            if( back )
                back->prev = p->prev;
            else
                last = p->prev;
            if( method )
                method(p->data);
            delete p;
            count--;
            return true;
        }
    }
    return false;
}
void NodeMgt::del(void* data)
{
    while(del_(data));
}
 
#else
 
void NodeMgt::del(void* data)
{
    for(Node* p = last, * back = NULL; p;)
        //back = p, p = p->prev)
    {
        if( p->data==data )
        {
            if( back )
                back->prev = p->prev;
            else
                last = p->prev;
            //back = back;// 000
            Node* bk = p->prev;// 111
            if( method )
                method(p->data);
            delete p;
            p = bk;
            count--;
        }
        else
        {
            back = p;// 000
            p = p->prev;// 111
        }
    }
}
#endif
    
void NodeMgt::delAll()
{
    for(Node* p = last; p; )
    {
        Node* bk = p->prev;
        if( method )
            method(p->data);
        delete p;
        p = bk;
    }
    last = NULL;
    count = 0;
}
 
void* NodeMgt::at(int index)
{
    int i = count - 1;
    for(Node* p = last; p; p = p->prev, i--)
    {
        if( i==index )
            return p->data;
    }
    return NULL;
}
 

 

매일매일 열심히 게임 개발하고 있습니다