Legends-of-Azeroth-Pandaria-5.4.8

1
/*
2
 * Copyright (C) 2011-2016 Project SkyFire <http://www.projectskyfire.org/>
3
 * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
4
 * Copyright (C) 2005-2016 MaNGOS <http://getmangos.com/>
5
 *
6
 * This program is free software; you can redistribute it and/or modify it
7
 * under the terms of the GNU General Public License as published by the
8
 * Free Software Foundation; either version 3 of the License, or (at your
9
 * option) any later version.
10
 *
11
 * This program is distributed in the hope that it will be useful, but WITHOUT
12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14
 * more details.
15
 *
16
 * You should have received a copy of the GNU General Public License along
17
 * with this program. If not, see <http://www.gnu.org/licenses/>.
18
 */
19

20
#include "vmapexport.h"
21
#include "adtfile.h"
22

23
#include <algorithm>
24
#include <cstdio>
25

26
#ifdef WIN32
27
#define snprintf _snprintf
28
#endif
29

30
char const* GetPlainName(char const* FileName)
31
{
32
    const char * szTemp;
33

34
    if((szTemp = strrchr(FileName, '\\')) != NULL)
35
        FileName = szTemp + 1;
36
    return FileName;
37
}
38

39
char* GetPlainName(char* FileName)
40
{
41
    char * szTemp;
42

43
    if((szTemp = strrchr(FileName, '\\')) != NULL)
44
        FileName = szTemp + 1;
45
    return FileName;
46
}
47

48
void FixNameCase(char* name, size_t len)
49
{
50
    char* ptr = name + len - 1;
51

52
    //extension in lowercase
53
    for (; *ptr != '.'; --ptr)
54
        *ptr |= 0x20;
55

56
    for (; ptr >= name; --ptr)
57
    {
58
        if (ptr > name && *ptr >= 'A' && *ptr <= 'Z' && isalpha(*(ptr - 1)))
59
            *ptr |= 0x20;
60
        else if ((ptr == name || !isalpha(*(ptr - 1))) && *ptr >= 'a' && *ptr <= 'z')
61
            *ptr &= ~0x20;
62
    }
63
}
64

65
void FixNameSpaces(char* name, size_t len)
66
{
67
    if (len < 3)
68
        return;
69

70
    for (size_t i=0; i<len-3; i++)
71
    {
72
        if(name[i] == ' ')
73
            name[i] = '_';
74
    }
75
}
76

77
void fixnamen(char* name, size_t len)
78
{
79
    if (len < 3)
80
        return;
81

82
    for (size_t i = 0; i < len - 3; i++)
83
    {
84
        if (i > 0 && name[i] >= 'A' && name[i] <= 'Z' && isalpha(name[i-1]))
85
            name[i] |= 0x20;
86
        else if ((i == 0 || !isalpha(name[i-1])) && name[i]>='a' && name[i]<='z')
87
            name[i] &= ~0x20;
88
    }
89
    //extension in lowercase
90
    for (size_t i = len - 3; i < len; i++)
91
        name[i] |= 0x20;
92
}
93

94
void fixname2(char* name, size_t len)
95
{
96
    if (len < 3)
97
        return;
98

99
    for (size_t i = 0; i < len - 3; i++)
100
        if (name[i] == ' ')
101
            name[i] = '_';
102
}
103

104
char* GetExtension(char* FileName)
105
{
106
    if (char* szTemp = strrchr(FileName, '.'))
107
        return szTemp;
108
    return nullptr;
109
}
110

111
extern HANDLE WorldMpq;
112

113
ADTFile::ADTFile(char* filename) : _file(WorldMpq, filename, false)
114
{
115
    Adtfilename.append(filename);
116
}
117

118
bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY)
119
{
120
    if (_file.isEof())
121
        return false;
122

123
    uint32 size;
124
    std::string dirname = std::string(szWorkDirWmo) + "/dir_bin";
125
    FILE *dirfile;
126
    dirfile = fopen(dirname.c_str(), "ab");
127
    if(!dirfile)
128
    {
129
        printf("Can't open dirfile!'%s'\n", dirname.c_str());
130
        return false;
131
    }
132

133
    while (!_file.isEof())
134
    {
135
        char fourcc[5];
136
        _file.read(&fourcc,4);
137
        _file.read(&size, 4);
138
        flipcc(fourcc);
139
        fourcc[4] = 0;
140

141
        size_t nextpos = _file.getPos() + size;
142

143
        if (!strcmp(fourcc,"MCIN"))
144
        {
145
        }
146
        else if (!strcmp(fourcc,"MTEX"))
147
        {
148
        }
149
        else if (!strcmp(fourcc,"MMDX"))
150
        {
151
            if (size)
152
            {
153
                char *buf = new char[size];
154
                _file.read(buf, size);
155
                char *p = buf;
156
                while (p < buf + size)
157
                {
158
                    fixnamen(p, strlen(p));
159
                    char* s = GetPlainName(p);
160
                    fixname2(s, strlen(s));
161

162
                    ModelInstanceNames.emplace_back(s);
163

164
                    std::string path(p);
165
                    ExtractSingleModel(path);
166

167
                    p = p+strlen(p)+1;
168
                }
169
                delete[] buf;
170
            }
171
        }
172
        else if (!strcmp(fourcc,"MWMO"))
173
        {
174
            if (size)
175
            {
176
                char* buf = new char[size];
177
                _file.read(buf, size);
178
                char* p = buf;
179
                while (p < buf + size)
180
                {
181
                    std::string path(p);
182

183
                    char* s = GetPlainName(p);
184
                    fixnamen(s, strlen(s));
185
                    fixname2(s, strlen(s));
186
                    WmoInstanceNames.emplace_back(s);
187

188
                    ExtractSingleWmo(path);
189

190
                    p += strlen(p) + 1;
191
                }
192
                delete[] buf;
193
            }
194
        }
195
        //======================
196
        else if (!strcmp(fourcc,"MDDF"))
197
        {
198
            if (size)
199
            {
200
                uint32 doodadCount = size / sizeof(ADT::MDDF);
201
                for (uint32 i = 0; i < doodadCount; ++i)
202
                {
203
                    ADT::MDDF doodadDef;
204
                    _file.read(&doodadDef, sizeof(ADT::MDDF));
205
                    Doodad::Extract(doodadDef, ModelInstanceNames[doodadDef.Id].c_str(), map_num, tileX, tileY, dirfile);
206
                }
207
            }
208
        }
209
        else if (!strcmp(fourcc,"MODF"))
210
        {
211
            if (size)
212
            {
213
                uint32 mapObjectCount = size / sizeof(ADT::MODF);
214
                for (uint32 i = 0; i < mapObjectCount; ++i)
215
                {
216
                    ADT::MODF mapObjDef;
217
                    _file.read(&mapObjDef, sizeof(ADT::MODF));
218
                    MapObject::Extract(mapObjDef, WmoInstanceNames[mapObjDef.Id].c_str(), map_num, tileX, tileY, dirfile);
219
                    Doodad::ExtractSet(WmoDoodads[WmoInstanceNames[mapObjDef.Id]], mapObjDef, map_num, tileX, tileY, dirfile);
220
                }
221
            }
222
        }
223

224
        //======================
225
        _file.seek(nextpos);
226
    }
227

228
    _file.close();
229
    fclose(dirfile);
230
    return true;
231
}
232

233
ADTFile::~ADTFile()
234
{
235
    _file.close();
236
}
237