Pacman/map.cpp at main · dangdtr/Pacman · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include "map.h"

GameMap::GameMap()
{
    ;
}
GameMap::~GameMap()
{
    ;
}


void GameMap::LoadMap(char* path)
{
    std::ifstream file(path);
    while(!file.eof())
        for (int i = 0; i < MAX_MAP_Y; i++)
        {
            for (int j = 0; j < MAX_MAP_X; j++)
            {
                int c;
                file >> c;
                game_map.tile[i][j] = c;
            }
        }
    file.close();
}


void GameMap::setClipTile()
{
    mCollision.resize(37);
    mCollision[0] = {0,0, TILE_SIZE * 19, TILE_SIZE};
    mCollision[1] = {0,TILE_SIZE, TILE_SIZE, TILE_SIZE * 8};
    mCollision[2] = {TILE_SIZE * 2, TILE_SIZE * 2, TILE_SIZE * 2, TILE_SIZE};
    mCollision[3] = {TILE_SIZE * 5, TILE_SIZE * 2, TILE_SIZE * 3, TILE_SIZE};
    mCollision[4] = {TILE_SIZE * 9, TILE_SIZE, TILE_SIZE, TILE_SIZE * 2};
    mCollision[5] = {TILE_SIZE * 11, TILE_SIZE * 2, TILE_SIZE * 3, TILE_SIZE};
    mCollision[6] = {TILE_SIZE * 15, TILE_SIZE * 2, TILE_SIZE * 2, TILE_SIZE};
    mCollision[7] = {TILE_SIZE * 18, TILE_SIZE, TILE_SIZE, TILE_SIZE * 8};
    mCollision[8] = {TILE_SIZE * 2, TILE_SIZE * 4, TILE_SIZE * 2, TILE_SIZE};
    mCollision[9] = {TILE_SIZE * 5, TILE_SIZE * 4, TILE_SIZE, TILE_SIZE * 5};
    mCollision[10]= {TILE_SIZE * 7, TILE_SIZE * 4, TILE_SIZE * 5, TILE_SIZE};
    mCollision[11]= {TILE_SIZE * 13, TILE_SIZE * 4, TILE_SIZE, TILE_SIZE * 5};
    mCollision[12]= {TILE_SIZE * 15, TILE_SIZE * 4, TILE_SIZE * 2, TILE_SIZE};
    mCollision[13]= {TILE_SIZE, TILE_SIZE * 6, TILE_SIZE * 3, TILE_SIZE * 3};
    mCollision[14]= {TILE_SIZE * 6,TILE_SIZE * 6, TILE_SIZE * 2, TILE_SIZE};
    mCollision[15]= {TILE_SIZE * 9, TILE_SIZE * 5, TILE_SIZE, TILE_SIZE * 2};
    mCollision[16]= {TILE_SIZE * 11, TILE_SIZE * 6, TILE_SIZE * 2, TILE_SIZE};
    mCollision[17]= {TILE_SIZE * 15, TILE_SIZE * 6, TILE_SIZE * 3, TILE_SIZE * 3};
    mCollision[18]= {0, TILE_SIZE * 10, TILE_SIZE, TILE_SIZE * 9};
    mCollision[19]= {TILE_SIZE, TILE_SIZE * 10,TILE_SIZE * 3, TILE_SIZE * 3};
    mCollision[20]= {TILE_SIZE * 5, TILE_SIZE * 10, TILE_SIZE, TILE_SIZE * 5};
    mCollision[21]= {TILE_SIZE * 6, TILE_SIZE * 12, TILE_SIZE * 2, TILE_SIZE};
    mCollision[22]= {TILE_SIZE * 11, TILE_SIZE * 12, TILE_SIZE * 2, TILE_SIZE};
    mCollision[23]= {TILE_SIZE * 13, TILE_SIZE * 10, TILE_SIZE,TILE_SIZE * 5};
    mCollision[24]= {TILE_SIZE * 15, TILE_SIZE * 10, TILE_SIZE * 3, TILE_SIZE * 3};
    mCollision[25]= {TILE_SIZE * 18, TILE_SIZE * 10, TILE_SIZE, TILE_SIZE * 9};
    mCollision[26]= {TILE_SIZE * 2, TILE_SIZE * 14, TILE_SIZE * 2, TILE_SIZE};
    mCollision[27]= {TILE_SIZE * 9, TILE_SIZE * 12, TILE_SIZE, TILE_SIZE * 2};
    mCollision[28]= {TILE_SIZE * 7, TILE_SIZE * 14, TILE_SIZE * 5, TILE_SIZE};
    mCollision[29]= {TILE_SIZE * 15, TILE_SIZE * 14, TILE_SIZE * 2, TILE_SIZE};
    mCollision[30]= {TILE_SIZE * 2, TILE_SIZE * 16, TILE_SIZE * 2, TILE_SIZE};
    mCollision[31]= {TILE_SIZE * 5, TILE_SIZE * 16, TILE_SIZE * 3, TILE_SIZE};
    mCollision[32]= {TILE_SIZE * 9, TILE_SIZE * 16, TILE_SIZE, TILE_SIZE * 2};
    mCollision[33]= {TILE_SIZE * 11, TILE_SIZE * 16, TILE_SIZE * 3, TILE_SIZE};
    mCollision[34]= {TILE_SIZE * 15, TILE_SIZE * 16, TILE_SIZE * 2, TILE_SIZE};
    mCollision[35]= {TILE_SIZE, TILE_SIZE * 18, TILE_SIZE * 17, TILE_SIZE};
    mCollision[36]= {TILE_SIZE * 7, TILE_SIZE * 8, TILE_SIZE * 5, TILE_SIZE * 3};
    mCollisionGHO.resize(41);
    for (int i = 0; i < 36; i++){
        mCollisionGHO[i] = mCollision[i];
    }
    mCollisionGHO[36]= {TILE_SIZE * 7, TILE_SIZE * 8, TILE_SIZE * 2, TILE_SIZE * 1};
    mCollisionGHO[37]= {TILE_SIZE * 10, TILE_SIZE * 8, TILE_SIZE * 2, TILE_SIZE * 1};
    mCollisionGHO[38]= {TILE_SIZE * 7, TILE_SIZE * 9, TILE_SIZE * 1, TILE_SIZE * 2};
    mCollisionGHO[39]= {TILE_SIZE * 11, TILE_SIZE * 9, TILE_SIZE * 1, TILE_SIZE * 2};
    mCollisionGHO[40]= {TILE_SIZE * 7, TILE_SIZE * 10, TILE_SIZE * 5, TILE_SIZE * 1};
}


std::vector<SDL_Rect>& GameMap::getColliders()
{
    return mCollision;
}
std::vector<SDL_Rect>& GameMap::getCollidersGHO()
{
    return mCollisionGHO;
}