Open Tibia Server List

Grow your Open Tibia server.

Reach new players • Build your community • Climb the rankings

Add Server Explore Servers

templatemapclassic.cpp

main 694 lines · 16.5 KB Raw

Alex Commit Map Editor 18/10/2026 23:40

1//////////////////////////////////////////////////////////////////////

2// This file is part of Remere's Map Editor

3//////////////////////////////////////////////////////////////////////

4// Remere's Map Editor is free software: you can redistribute it and/or modify

5// it under the terms of the GNU General Public License as published by

6// the Free Software Foundation, either version 3 of the License, or

7// (at your option) any later version.

8//

9// Remere's Map Editor is distributed in the hope that it will be useful,

10// but WITHOUT ANY WARRANTY; without even the implied warranty of

11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12// GNU General Public License for more details.

13//

14// You should have received a copy of the GNU General Public License

15// along with this program. If not, see <http://www.gnu.org/licenses/>.

16//////////////////////////////////////////////////////////////////////

18#include "main.h"

20#include "templates.h"

22ConversionMap getReplacementMapClassic() {

23 ConversionMap replacement_map;

24 std::vector<uint16_t> veckey, vecval;

26 vecval.clear();

27 vecval.push_back(102);

28 replacement_map.stm[102] = vecval;

30 vecval.clear();

31 vecval.push_back(105);

32 replacement_map.stm[105] = vecval;

34 vecval.clear();

35 vecval.push_back(107);

36 replacement_map.stm[107] = vecval;

38 vecval.clear();

39 vecval.push_back(146);

40 veckey.clear();

41 veckey.push_back(105);

42 veckey.push_back(4667);

43 std::sort(veckey.begin(), veckey.end());

44 replacement_map.mtm[veckey] = vecval;

46 vecval.clear();

47 vecval.push_back(147);

48 veckey.clear();

49 veckey.push_back(105);

50 veckey.push_back(4669);

51 std::sort(veckey.begin(), veckey.end());

52 replacement_map.mtm[veckey] = vecval;

54 vecval.clear();

55 vecval.push_back(148);

56 veckey.clear();

57 veckey.push_back(105);

58 veckey.push_back(4670);

59 std::sort(veckey.begin(), veckey.end());

60 replacement_map.mtm[veckey] = vecval;

62 vecval.clear();

63 vecval.push_back(149);

64 veckey.clear();

65 veckey.push_back(105);

66 veckey.push_back(4668);

67 std::sort(veckey.begin(), veckey.end());

68 replacement_map.mtm[veckey] = vecval;

70 vecval.clear();

71 vecval.push_back(150);

72 veckey.clear();

73 veckey.push_back(105);

74 veckey.push_back(4675);

75 std::sort(veckey.begin(), veckey.end());

76 replacement_map.mtm[veckey] = vecval;

78 vecval.clear();

79 vecval.push_back(151);

80 veckey.clear();

81 veckey.push_back(105);

82 veckey.push_back(4676);

83 std::sort(veckey.begin(), veckey.end());

84 replacement_map.mtm[veckey] = vecval;

86 vecval.clear();

87 vecval.push_back(152);

88 veckey.clear();

89 veckey.push_back(105);

90 veckey.push_back(4678);

91 std::sort(veckey.begin(), veckey.end());

92 replacement_map.mtm[veckey] = vecval;

94 vecval.clear();

95 vecval.push_back(153);

96 veckey.clear();

97 veckey.push_back(4566);

98 veckey.push_back(4677);

99 std::sort(veckey.begin(), veckey.end());

100 replacement_map.mtm[veckey] = vecval;

101

102 vecval.clear();

103 vecval.push_back(154);

104 veckey.clear();

105 veckey.push_back(105);

106 veckey.push_back(4671);

107 std::sort(veckey.begin(), veckey.end());

108 replacement_map.mtm[veckey] = vecval;

109

110 vecval.clear();

111 vecval.push_back(155);

112 veckey.clear();

113 veckey.push_back(105);

114 veckey.push_back(4672);

115 std::sort(veckey.begin(), veckey.end());

116 replacement_map.mtm[veckey] = vecval;

117

118 vecval.clear();

119 vecval.push_back(156);

120 veckey.clear();

121 veckey.push_back(105);

122 veckey.push_back(4674);

123 std::sort(veckey.begin(), veckey.end());

124 replacement_map.mtm[veckey] = vecval;

125

126 vecval.clear();

127 vecval.push_back(157);

128 veckey.clear();

129 veckey.push_back(105);

130 veckey.push_back(4673);

131 std::sort(veckey.begin(), veckey.end());

132 replacement_map.mtm[veckey] = vecval;

133

134 vecval.clear();

135 vecval.push_back(158);

136 veckey.clear();

137 veckey.push_back(105);

138 veckey.push_back(4596);

139 std::sort(veckey.begin(), veckey.end());

140 replacement_map.mtm[veckey] = vecval;

141

142 vecval.clear();

143 vecval.push_back(159);

144 veckey.clear();

145 veckey.push_back(105);

146 veckey.push_back(4598);

147 std::sort(veckey.begin(), veckey.end());

148 replacement_map.mtm[veckey] = vecval;

149

150 vecval.clear();

151 vecval.push_back(160);

152 veckey.clear();

153 veckey.push_back(105);

154 veckey.push_back(4599);

155 std::sort(veckey.begin(), veckey.end());

156 replacement_map.mtm[veckey] = vecval;

157

158 vecval.clear();

159 vecval.push_back(161);

160 veckey.clear();

161 veckey.push_back(105);

162 veckey.push_back(4597);

163 std::sort(veckey.begin(), veckey.end());

164 replacement_map.mtm[veckey] = vecval;

165

166 vecval.clear();

167 vecval.push_back(162);

168 veckey.clear();

169 veckey.push_back(105);

170 veckey.push_back(4604);

171 std::sort(veckey.begin(), veckey.end());

172 replacement_map.mtm[veckey] = vecval;

173

174 vecval.clear();

175 vecval.push_back(163);

176 veckey.clear();

177 veckey.push_back(105);

178 veckey.push_back(4605);

179 std::sort(veckey.begin(), veckey.end());

180 replacement_map.mtm[veckey] = vecval;

181

182 vecval.clear();

183 vecval.push_back(164);

184 veckey.clear();

185 veckey.push_back(105);

186 veckey.push_back(4607);

187 std::sort(veckey.begin(), veckey.end());

188 replacement_map.mtm[veckey] = vecval;

189

190 vecval.clear();

191 vecval.push_back(165);

192 veckey.clear();

193 veckey.push_back(105);

194 veckey.push_back(4606);

195 std::sort(veckey.begin(), veckey.end());

196 replacement_map.mtm[veckey] = vecval;

197

198 vecval.clear();

199 vecval.push_back(166);

200 veckey.clear();

201 veckey.push_back(105);

202 veckey.push_back(4600);

203 std::sort(veckey.begin(), veckey.end());

204 replacement_map.mtm[veckey] = vecval;

205

206 vecval.clear();

207 vecval.push_back(167);

208 veckey.clear();

209 veckey.push_back(105);

210 veckey.push_back(4601);

211 std::sort(veckey.begin(), veckey.end());

212 replacement_map.mtm[veckey] = vecval;

213

214 vecval.clear();

215 vecval.push_back(168);

216 veckey.clear();

217 veckey.push_back(105);

218 veckey.push_back(4603);

219 std::sort(veckey.begin(), veckey.end());

220 replacement_map.mtm[veckey] = vecval;

221

222 vecval.clear();

223 vecval.push_back(169);

224 veckey.clear();

225 veckey.push_back(105);

226 veckey.push_back(4602);

227 std::sort(veckey.begin(), veckey.end());

228 replacement_map.mtm[veckey] = vecval;

229

230 vecval.clear();

231 vecval.push_back(219);

232 veckey.clear();

233 veckey.push_back(106);

234 veckey.push_back(4542);

235 std::sort(veckey.begin(), veckey.end());

236 replacement_map.mtm[veckey] = vecval;

237

238 vecval.clear();

239 vecval.push_back(220);

240 veckey.clear();

241 veckey.push_back(106);

242 veckey.push_back(4544);

243 std::sort(veckey.begin(), veckey.end());

244 replacement_map.mtm[veckey] = vecval;

245

246 vecval.clear();

247 vecval.push_back(221);

248 veckey.clear();

249 veckey.push_back(106);

250 veckey.push_back(4545);

251 std::sort(veckey.begin(), veckey.end());

252 replacement_map.mtm[veckey] = vecval;

253

254 vecval.clear();

255 vecval.push_back(222);

256 veckey.clear();

257 veckey.push_back(106);

258 veckey.push_back(4543);

259 std::sort(veckey.begin(), veckey.end());

260 replacement_map.mtm[veckey] = vecval;

261

262 vecval.clear();

263 vecval.push_back(223);

264 veckey.clear();

265 veckey.push_back(106);

266 veckey.push_back(4550);

267 std::sort(veckey.begin(), veckey.end());

268 replacement_map.mtm[veckey] = vecval;

269

270 vecval.clear();

271 vecval.push_back(224);

272 veckey.clear();

273 veckey.push_back(106);

274 veckey.push_back(4551);

275 std::sort(veckey.begin(), veckey.end());

276 replacement_map.mtm[veckey] = vecval;

277

278 vecval.clear();

279 vecval.push_back(225);

280 veckey.clear();

281 veckey.push_back(106);

282 veckey.push_back(4553);

283 std::sort(veckey.begin(), veckey.end());

284 replacement_map.mtm[veckey] = vecval;

285

286 vecval.clear();

287 vecval.push_back(226);

288 veckey.clear();

289 veckey.push_back(106);

290 veckey.push_back(4552);

291 std::sort(veckey.begin(), veckey.end());

292 replacement_map.mtm[veckey] = vecval;

293

294 vecval.clear();

295 vecval.push_back(227);

296 veckey.clear();

297 veckey.push_back(106);

298 veckey.push_back(4546);

299 std::sort(veckey.begin(), veckey.end());

300 replacement_map.mtm[veckey] = vecval;

301

302 vecval.clear();

303 vecval.push_back(228);

304 veckey.clear();

305 veckey.push_back(106);

306 veckey.push_back(4547);

307 std::sort(veckey.begin(), veckey.end());

308 replacement_map.mtm[veckey] = vecval;

309

310 vecval.clear();

311 vecval.push_back(229);

312 veckey.clear();

313 veckey.push_back(106);

314 veckey.push_back(4549);

315 std::sort(veckey.begin(), veckey.end());

316 replacement_map.mtm[veckey] = vecval;

317

318 vecval.clear();

319 vecval.push_back(230);

320 veckey.clear();

321 veckey.push_back(106);

322 veckey.push_back(4548);

323 std::sort(veckey.begin(), veckey.end());

324 replacement_map.mtm[veckey] = vecval;

325

326 vecval.clear();

327 vecval.push_back(232);

328 veckey.clear();

329 veckey.push_back(231);

330 veckey.push_back(4542);

331 std::sort(veckey.begin(), veckey.end());

332 replacement_map.mtm[veckey] = vecval;

333

334 vecval.clear();

335 vecval.push_back(233);

336 veckey.clear();

337 veckey.push_back(231);

338 veckey.push_back(4544);

339 std::sort(veckey.begin(), veckey.end());

340 replacement_map.mtm[veckey] = vecval;

341

342 vecval.clear();

343 vecval.push_back(234);

344 veckey.clear();

345 veckey.push_back(231);

346 veckey.push_back(4545);

347 std::sort(veckey.begin(), veckey.end());

348 replacement_map.mtm[veckey] = vecval;

349

350 vecval.clear();

351 vecval.push_back(235);

352 veckey.clear();

353 veckey.push_back(231);

354 veckey.push_back(4543);

355 std::sort(veckey.begin(), veckey.end());

356 replacement_map.mtm[veckey] = vecval;

357

358 vecval.clear();

359 vecval.push_back(236);

360 veckey.clear();

361 veckey.push_back(231);

362 veckey.push_back(4550);

363 std::sort(veckey.begin(), veckey.end());

364 replacement_map.mtm[veckey] = vecval;

365

366 vecval.clear();

367 vecval.push_back(237);

368 veckey.clear();

369 veckey.push_back(231);

370 veckey.push_back(4551);

371 std::sort(veckey.begin(), veckey.end());

372 replacement_map.mtm[veckey] = vecval;

373

374 vecval.clear();

375 vecval.push_back(238);

376 veckey.clear();

377 veckey.push_back(231);

378 veckey.push_back(4553);

379 std::sort(veckey.begin(), veckey.end());

380 replacement_map.mtm[veckey] = vecval;

381

382 vecval.clear();

383 vecval.push_back(239);

384 veckey.clear();

385 veckey.push_back(231);

386 veckey.push_back(4552);

387 std::sort(veckey.begin(), veckey.end());

388 replacement_map.mtm[veckey] = vecval;

389

390 vecval.clear();

391 vecval.push_back(240);

392 veckey.clear();

393 veckey.push_back(231);

394 veckey.push_back(4546);

395 std::sort(veckey.begin(), veckey.end());

396 replacement_map.mtm[veckey] = vecval;

397

398 vecval.clear();

399 vecval.push_back(241);

400 veckey.clear();

401 veckey.push_back(231);

402 veckey.push_back(4547);

403 std::sort(veckey.begin(), veckey.end());

404 replacement_map.mtm[veckey] = vecval;

405

406 vecval.clear();

407 vecval.push_back(242);

408 veckey.clear();

409 veckey.push_back(231);

410 veckey.push_back(4549);

411 std::sort(veckey.begin(), veckey.end());

412 replacement_map.mtm[veckey] = vecval;

413

414 vecval.clear();

415 vecval.push_back(243);

416 veckey.clear();

417 veckey.push_back(231);

418 veckey.push_back(4548);

419 std::sort(veckey.begin(), veckey.end());

420 replacement_map.mtm[veckey] = vecval;

421

422 vecval.clear();

423 vecval.push_back(296);

424 veckey.clear();

425 veckey.push_back(103);

426 veckey.push_back(4599);

427 veckey.push_back(4542);

428 std::sort(veckey.begin(), veckey.end());

429 replacement_map.mtm[veckey] = vecval;

430

431 vecval.clear();

432 vecval.push_back(297);

433 veckey.clear();

434 veckey.push_back(103);

435 veckey.push_back(4597);

436 veckey.push_back(4544);

437 std::sort(veckey.begin(), veckey.end());

438 replacement_map.mtm[veckey] = vecval;

439

440 vecval.clear();

441 vecval.push_back(298);

442 veckey.clear();

443 veckey.push_back(103);

444 veckey.push_back(4599);

445 veckey.push_back(4544);

446 std::sort(veckey.begin(), veckey.end());

447 replacement_map.mtm[veckey] = vecval;

448

449 vecval.clear();

450 vecval.push_back(299);

451 veckey.clear();

452 veckey.push_back(103);

453 veckey.push_back(4596);

454 veckey.push_back(4543);

455 std::sort(veckey.begin(), veckey.end());

456 replacement_map.mtm[veckey] = vecval;

457

458 vecval.clear();

459 vecval.push_back(300);

460 veckey.clear();

461 veckey.push_back(103);

462 veckey.push_back(4598);

463 veckey.push_back(4543);

464 std::sort(veckey.begin(), veckey.end());

465 replacement_map.mtm[veckey] = vecval;

466

467 vecval.clear();

468 vecval.push_back(301);

469 veckey.clear();

470 veckey.push_back(103);

471 veckey.push_back(4596);

472 veckey.push_back(4545);

473 std::sort(veckey.begin(), veckey.end());

474 replacement_map.mtm[veckey] = vecval;

475

476 vecval.clear();

477 vecval.push_back(302);

478 veckey.clear();

479 veckey.push_back(103);

480 veckey.push_back(4598);

481 veckey.push_back(4545);

482 std::sort(veckey.begin(), veckey.end());

483 replacement_map.mtm[veckey] = vecval;

484

485 vecval.clear();

486 vecval.push_back(304);

487 veckey.clear();

488 veckey.push_back(4566);

489 veckey.push_back(4670);

490 veckey.push_back(4542);

491 std::sort(veckey.begin(), veckey.end());

492 replacement_map.mtm[veckey] = vecval;

493

494 vecval.clear();

495 vecval.push_back(305);

496 veckey.clear();

497 veckey.push_back(4566);

498 veckey.push_back(4668);

499 veckey.push_back(4544);

500 std::sort(veckey.begin(), veckey.end());

501 replacement_map.mtm[veckey] = vecval;

502

503 vecval.clear();

504 vecval.push_back(306);

505 veckey.clear();

506 veckey.push_back(4566);

507 veckey.push_back(4670);

508 veckey.push_back(4544);

509 std::sort(veckey.begin(), veckey.end());

510 replacement_map.mtm[veckey] = vecval;

511

512 vecval.clear();

513 vecval.push_back(307);

514 veckey.clear();

515 veckey.push_back(4566);

516 veckey.push_back(4667);

517 veckey.push_back(4543);

518 std::sort(veckey.begin(), veckey.end());

519 replacement_map.mtm[veckey] = vecval;

520

521 vecval.clear();

522 vecval.push_back(308);

523 veckey.clear();

524 veckey.push_back(4566);

525 veckey.push_back(4667);

526 veckey.push_back(4545);

527 std::sort(veckey.begin(), veckey.end());

528 replacement_map.mtm[veckey] = vecval;

529

530 vecval.clear();

531 vecval.push_back(309);

532 veckey.clear();

533 veckey.push_back(4566);

534 veckey.push_back(4669);

535 veckey.push_back(4543);

536 std::sort(veckey.begin(), veckey.end());

537 replacement_map.mtm[veckey] = vecval;

538

539 vecval.clear();

540 vecval.push_back(310);

541 veckey.clear();

542 veckey.push_back(4566);

543 veckey.push_back(4669);

544 veckey.push_back(4545);

545 std::sort(veckey.begin(), veckey.end());

546 replacement_map.mtm[veckey] = vecval;

547

548 vecval.clear();

549 vecval.push_back(311);

550 veckey.clear();

551 veckey.push_back(4566);

552 veckey.push_back(4597);

553 veckey.push_back(4542);

554 std::sort(veckey.begin(), veckey.end());

555 replacement_map.mtm[veckey] = vecval;

556

557 vecval.clear();

558 vecval.push_back(312);

559 veckey.clear();

560 veckey.push_back(4566);

561 veckey.push_back(4599);

562 veckey.push_back(4542);

563 std::sort(veckey.begin(), veckey.end());

564 replacement_map.mtm[veckey] = vecval;

565

566 vecval.clear();

567 vecval.push_back(313);

568 veckey.clear();

569 veckey.push_back(4566);

570 veckey.push_back(4597);

571 veckey.push_back(4544);

572 std::sort(veckey.begin(), veckey.end());

573 replacement_map.mtm[veckey] = vecval;

574

575 vecval.clear();

576 vecval.push_back(314);

577 veckey.clear();

578 veckey.push_back(4566);

579 veckey.push_back(4599);

580 veckey.push_back(4544);

581 std::sort(veckey.begin(), veckey.end());

582 replacement_map.mtm[veckey] = vecval;

583

584 vecval.clear();

585 vecval.push_back(315);

586 veckey.clear();

587 veckey.push_back(4566);

588 veckey.push_back(4596);

589 veckey.push_back(4543);

590 std::sort(veckey.begin(), veckey.end());

591 replacement_map.mtm[veckey] = vecval;

592

593 vecval.clear();

594 vecval.push_back(316);

595 veckey.clear();

596 veckey.push_back(4566);

597 veckey.push_back(4598);

598 veckey.push_back(4543);

599 std::sort(veckey.begin(), veckey.end());

600 replacement_map.mtm[veckey] = vecval;

601

602 vecval.clear();

603 vecval.push_back(317);

604 veckey.clear();

605 veckey.push_back(4566);

606 veckey.push_back(4596);

607 veckey.push_back(4545);

608 std::sort(veckey.begin(), veckey.end());

609 replacement_map.mtm[veckey] = vecval;

610

611 vecval.clear();

612 vecval.push_back(318);

613 veckey.clear();

614 veckey.push_back(4566);

615 veckey.push_back(4598);

616 veckey.push_back(4545);

617 std::sort(veckey.begin(), veckey.end());

618 replacement_map.mtm[veckey] = vecval;

619

620 vecval.clear();

621 vecval.push_back(319);

622 veckey.clear();

623 veckey.push_back(4566);

624 veckey.push_back(4670);

625 veckey.push_back(4596);

626 std::sort(veckey.begin(), veckey.end());

627 replacement_map.mtm[veckey] = vecval;

628

629 vecval.clear();

630 vecval.push_back(320);

631 veckey.clear();

632 veckey.push_back(4566);

633 veckey.push_back(4668);

634 veckey.push_back(4596);

635 std::sort(veckey.begin(), veckey.end());

636 replacement_map.mtm[veckey] = vecval;

637

638 vecval.clear();

639 vecval.push_back(321);

640 veckey.clear();

641 veckey.push_back(4566);

642 veckey.push_back(4670);

643 veckey.push_back(4598);

644 std::sort(veckey.begin(), veckey.end());

645 replacement_map.mtm[veckey] = vecval;

646

647 vecval.clear();

648 vecval.push_back(322);

649 veckey.clear();

650 veckey.push_back(4566);

651 veckey.push_back(4668);

652 veckey.push_back(4598);

653 std::sort(veckey.begin(), veckey.end());

654 replacement_map.mtm[veckey] = vecval;

655

656 vecval.clear();

657 vecval.push_back(323);

658 veckey.clear();

659 veckey.push_back(4566);

660 veckey.push_back(4667);

661 veckey.push_back(4597);

662 std::sort(veckey.begin(), veckey.end());

663 replacement_map.mtm[veckey] = vecval;

664

665 vecval.clear();

666 vecval.push_back(324);

667 veckey.clear();

668 veckey.push_back(4566);

669 veckey.push_back(4669);

670 veckey.push_back(4597);

671 std::sort(veckey.begin(), veckey.end());

672 replacement_map.mtm[veckey] = vecval;

673

674 vecval.clear();

675 vecval.push_back(325);

676 veckey.clear();

677 veckey.push_back(4566);

678 veckey.push_back(4667);

679 veckey.push_back(4599);

680 std::sort(veckey.begin(), veckey.end());

681 replacement_map.mtm[veckey] = vecval;

682

683 vecval.clear();

684 vecval.push_back(326);

685 veckey.clear();

686 veckey.push_back(4566);

687 veckey.push_back(4669);

688 veckey.push_back(4599);

689 std::sort(veckey.begin(), veckey.end());

690 replacement_map.mtm[veckey] = vecval;

691

692 return replacement_map;

693}

694