From aeaf728dc662b80b6f6e377db67ddb3ac4f9cacb Mon Sep 17 00:00:00 2001 From: Andrew Kurushin Date: Fri, 28 Jan 2005 19:25:41 +0000 Subject: partialy implemented all Iso mode resource loading todo: loadMulti - may be wrong svn-id: r16670 --- saga/isomap.cpp | 319 +++++++++++++++++++++++++++++++++----------------------- 1 file changed, 187 insertions(+), 132 deletions(-) (limited to 'saga/isomap.cpp') diff --git a/saga/isomap.cpp b/saga/isomap.cpp index 53f963e3e6..76ec5bfe7e 100644 --- a/saga/isomap.cpp +++ b/saga/isomap.cpp @@ -31,104 +31,169 @@ namespace Saga { -IsoMap::IsoMap(Gfx *gfx) { - _gfx = gfx; - _init = 1; - _tiles_loaded = 0; +IsoMap::IsoMap(SagaEngine *vm) : _vm(vm) { + _tileData = NULL; + _tilesCount = 0; + _tilePlatformList = NULL; + _tilePlatformsCount = 0; + _metaTileList = NULL; + _metaTilesCount = 0; + _multiTable = NULL; + _multiCount = 0; } -int IsoMap::loadTileset(const byte *tileres_p, size_t tileres_len) { - ISOTILE_ENTRY first_entry; - ISOTILE_ENTRY *tile_tbl; - +void IsoMap::loadImages(const byte *resourcePointer, size_t resourceLength) { + IsoTileData *tileData; uint16 i; - assert((_init) && (!_tiles_loaded)); - assert((tileres_p != NULL) && (tileres_len > 0)); - - MemoryReadStreamEndian readS(tileres_p, tileres_len, IS_BIG_ENDIAN); + if (resourceLength == 0) { + error("IsoMap::loadImages wrong resourceLength"); + } + _tileData = (byte*)malloc(resourceLength); + _tileDataLength = resourceLength; + memcpy(_tileData, resourcePointer, resourceLength); + + MemoryReadStreamEndian readS(_tileData, _tileDataLength, IS_BIG_ENDIAN); readS.readUint16(); // skip - first_entry.tile_offset = readS.readUint16(); - - _tile_ct = first_entry.tile_offset / SAGA_ISOTILE_ENTRY_LEN; + _tilesCount = readS.readUint16(); + _tilesCount = _tilesCount / SAGA_ISOTILEDATA_LEN; readS.seek(0); - tile_tbl = (ISOTILE_ENTRY *)malloc(_tile_ct * sizeof(*tile_tbl)); - if (tile_tbl == NULL) { - return MEM; + _tilesTable = (IsoTileData *)malloc(_tilesCount * sizeof(*_tilesTable)); + if (_tilesTable == NULL) { + memoryError("IsoMap::loadImages"); } - for (i = 0; i < _tile_ct; i++) { - tile_tbl[i].tile_h = readS.readByte(); - tile_tbl[i].mask_rule = readS.readByte(); - tile_tbl[i].tile_offset = readS.readUint16(); - tile_tbl[i].terrain_mask = readS.readSint16(); - tile_tbl[i].mask = readS.readSint16(); + for (i = 0; i < _tilesCount; i++) { + tileData = &_tilesTable[i]; + tileData->height = readS.readByte(); + tileData->attributes = readS.readByte(); + tileData->offset = readS.readUint16(); + tileData->terrainMask = readS.readSint16(); + tileData->FGBGAttr = readS.readByte(); + readS.readByte(); //skip } - _tiles_loaded = 1; - _tile_tbl = tile_tbl; - _tileres_p = tileres_p; - _tileres_len = tileres_len; - - return SUCCESS; } -int IsoMap::loadMetaTileset(const byte *mtileres_p, size_t mtileres_len) { - ISO_METATILE_ENTRY *mtile_tbl; - uint16 mtile_ct; - uint16 ct; - int i; +void IsoMap::loadPlatforms(const byte * resourcePointer, size_t resourceLength) { + TilePlatformData *tilePlatformData; + uint16 i, x, y; - assert(_init); - assert((mtileres_p != NULL) && (mtileres_len > 0)); + if (resourceLength == 0) { + error("IsoMap::loadPlatforms wrong resourceLength"); + } - MemoryReadStreamEndian readS(mtileres_p, mtileres_len, IS_BIG_ENDIAN); + MemoryReadStreamEndian readS(resourcePointer, resourceLength, IS_BIG_ENDIAN); - mtile_ct = mtileres_len / SAGA_METATILE_ENTRY_LEN; - mtile_tbl = (ISO_METATILE_ENTRY *)malloc(mtile_ct * sizeof(*mtile_tbl)); - if (mtile_tbl == NULL) { - return MEM; + _tilePlatformsCount = resourceLength / SAGA_TILEPLATFORMDATA_LEN; + _tilePlatformList = (TilePlatformData *)malloc(_tilePlatformsCount * sizeof(*_tilePlatformList)); + if (_tilePlatformList == NULL) { + memoryError("IsoMap::loadPlatforms"); } - for (ct = 0; ct < mtile_ct; ct++) { - mtile_tbl[ct].mtile_n = readS.readUint16(); - mtile_tbl[ct].height = readS.readSint16(); - mtile_tbl[ct].highest_pixel = readS.readSint16(); - mtile_tbl[ct].v_bits = readS.readByte(); - mtile_tbl[ct].u_bits = readS.readByte(); - for (i = 0; i < SAGA_METATILE_SIZE; i++) { - mtile_tbl[ct].tile_tbl[i] = readS.readUint16(); + for (i = 0; i < _tilePlatformsCount; i++) { + tilePlatformData = &_tilePlatformList[i]; + tilePlatformData->metaTile = readS.readSint16(); + tilePlatformData->height = readS.readSint16(); + tilePlatformData->highestPixel = readS.readSint16(); + tilePlatformData->vBits = readS.readByte(); + tilePlatformData->uBits = readS.readByte(); + for (y = 0; y < SAGA_PLATFORM_W; y++) { + for (x = 0; x < SAGA_PLATFORM_W; x++) { + tilePlatformData->tiles[x][y] = readS.readSint16(); + } } } - _mtile_ct = mtile_ct; - _mtile_tbl = mtile_tbl; - _mtileres_p = mtileres_p; - _mtileres_len = mtileres_len; +} - _mtiles_loaded = 1; +void IsoMap::loadMap(const byte * resourcePointer, size_t resourceLength) { + uint16 x, y; + + if (resourceLength != SAGA_TILEMAP_LEN) { + error("IsoMap::loadMap wrong resourceLength"); + } + + MemoryReadStreamEndian readS(resourcePointer, resourceLength, IS_BIG_ENDIAN); + _tileMap.edgeType = readS.readByte(); + readS.readByte(); //skip + + for (y = 0; y < SAGA_TILEMAP_H; y++) { + for (x = 0; x < SAGA_TILEMAP_W; x++) { + _tileMap.tilePlatforms[x][y] = readS.readSint16(); + } + } - return SUCCESS; } -int IsoMap::loadMetamap(const byte *mm_res_p, size_t mm_res_len) { - int i; +void IsoMap::loadMetaTiles(const byte * resourcePointer, size_t resourceLength) { + MetaTileData *metaTileData; + uint16 i, j; - MemoryReadStreamEndian readS(mm_res_p, mm_res_len, IS_BIG_ENDIAN); - _metamap_n = readS.readSint16(); + if (resourceLength == 0) { + error("IsoMap::loadMetaTiles wrong resourceLength"); + } - for (i = 0; i < SAGA_METAMAP_SIZE; i++) { - _metamap_tbl[i] = readS.readUint16(); + MemoryReadStreamEndian readS(resourcePointer, resourceLength, IS_BIG_ENDIAN); + _metaTilesCount = resourceLength / SAGA_METATILEDATA_LEN; + + _metaTileList = (MetaTileData *)malloc(_metaTilesCount * sizeof(*_metaTileList)); + if (_metaTileList == NULL) { + memoryError("IsoMap::loadMetaTiles"); } - _mm_res_p = mm_res_p; - _mm_res_len = mm_res_len; - _metamap_loaded = 1; + for (i = 0; i < _metaTilesCount; i++) { + metaTileData = &_metaTileList[i]; + metaTileData->highestPlatform = readS.readUint16(); + metaTileData->highestPixel = readS.readUint16(); + for (j = 0; j < SAGA_MAX_PLATFORM_H; j++) { + metaTileData->stack[j] = readS.readSint16(); + } + } +} - return SUCCESS; +void IsoMap::loadMulti(const byte * resourcePointer, size_t resourceLength) { + MultiTileEntryData *multiTileEntryData; + uint16 i; + + if (resourceLength < 2) { + error("IsoMap::loadMetaTiles wrong resourceLength"); + } + + MemoryReadStreamEndian readS(resourcePointer, resourceLength, IS_BIG_ENDIAN); + _multiCount = readS.readUint16(); + _multiTable = (MultiTileEntryData *)malloc(_multiCount * sizeof(*_multiTable)); + if (_multiTable == NULL) { + memoryError("IsoMap::loadMulti"); + } + debug(0,"resourceLength=%d but should be %d",resourceLength, 12*_multiCount + 2); + for (i = 0; i < _multiCount; i++) { + multiTileEntryData = &_multiTable[i]; + readS.readUint16();//skip + multiTileEntryData->offset = readS.readSint16(); + multiTileEntryData->u = readS.readByte(); + multiTileEntryData->v = readS.readByte(); + multiTileEntryData->h = readS.readByte(); + multiTileEntryData->uSize = readS.readByte(); + multiTileEntryData->vSize = readS.readByte(); + multiTileEntryData->numStates = readS.readByte(); + multiTileEntryData->currentState = readS.readByte(); + readS.readByte();//skip + } +} + +void IsoMap::freeMem() { + free(_tileData); + _tilesCount = 0; + free(_tilePlatformList); + _tilePlatformsCount = 0; + free(_metaTileList); + _metaTilesCount = 0; + free(_multiTable); + _multiCount = 0; } int IsoMap::draw(SURFACE *dst_s) { @@ -141,136 +206,126 @@ int IsoMap::draw(SURFACE *dst_s) { } int IsoMap::drawMetamap(SURFACE *dst_s, int map_x, int map_y) { - int meta_base_x = map_x; +/* int meta_base_x = map_x; int meta_base_y = map_y; int meta_xi; int meta_yi; - int meta_x; - int meta_y; int meta_idx; + Point platformPoint; for (meta_yi = SAGA_METAMAP_H - 1; meta_yi >= 0; meta_yi--) { - meta_x = meta_base_x; - meta_y = meta_base_y; + platformPoint.x = meta_base_x; + platformPoint.y = meta_base_y; for (meta_xi = SAGA_METAMAP_W - 1; meta_xi >= 0; meta_xi--) { meta_idx = meta_xi + (meta_yi * 16); - drawMetaTile(dst_s, _metamap_tbl[meta_idx], meta_x, meta_y); - meta_x += 128; - meta_y += 64; + drawMetaTile(dst_s, _metamap_tbl[meta_idx], platformPoint); + platformPoint.x += 128; + platformPoint.y += 64; } meta_base_x -= 128; meta_base_y += 64; } - +*/ return SUCCESS; } -int IsoMap::drawMetaTile(SURFACE *dst_s, uint16 mtile_i, int mtile_x, int mtile_y) { - int tile_xi; - int tile_yi; - int tile_x; - int tile_y; - int tile_base_x; - int tile_base_y; - int tile_i; - ISO_METATILE_ENTRY *mtile_p; - assert(_init && _mtiles_loaded); - - if (mtile_i >= _mtile_ct) { +int IsoMap::drawMetaTile(SURFACE *ds, uint16 platformNumber, const Point &point) { + int x; + int y; + + TilePlatformData *tilePlatformData; + Point tilePoint; + Point tileBasePoint; + + if (platformNumber >= _tilePlatformsCount) { return FAILURE; } - mtile_p = &_mtile_tbl[mtile_i]; + tilePlatformData = &_tilePlatformList[platformNumber]; - tile_base_x = mtile_x; - tile_base_y = mtile_y; + tileBasePoint = point; - for (tile_yi = SAGA_METATILE_H - 1; tile_yi >= 0; tile_yi--) { - tile_y = tile_base_y; - tile_x = tile_base_x; - for (tile_xi = SAGA_METATILE_W - 1; tile_xi >= 0; tile_xi--) { - tile_i = tile_xi + (tile_yi * SAGA_METATILE_W); - drawTile(dst_s, mtile_p->tile_tbl[tile_i], tile_x, tile_y); - tile_x += SAGA_ISOTILE_WIDTH / 2; - tile_y += SAGA_ISOTILE_BASEHEIGHT / 2 + 1; + for (y = SAGA_PLATFORM_W - 1; y >= 0; y--) { + tilePoint = tileBasePoint; + for (x = SAGA_PLATFORM_W - 1; x >= 0; x--) { + drawTile(ds, tilePlatformData->tiles[x][y], tilePoint); + tilePoint.x += SAGA_ISOTILE_WIDTH / 2; + tilePoint.y += SAGA_ISOTILE_BASEHEIGHT / 2 + 1; } - tile_base_x -= SAGA_ISOTILE_WIDTH / 2; - tile_base_y += SAGA_ISOTILE_BASEHEIGHT / 2 + 1; + tileBasePoint.x -= SAGA_ISOTILE_WIDTH / 2; + tileBasePoint.y += SAGA_ISOTILE_BASEHEIGHT / 2 + 1; } return SUCCESS; } -int IsoMap::drawTile(SURFACE *dst_s, uint16 tile_i, int tile_x, int tile_y) { - const byte *tile_p; - const byte *read_p; - byte *draw_p; - int draw_x; - int draw_y; - int tile_h; - int w_count = 0; +int IsoMap::drawTile(SURFACE *ds, uint16 tileNumber, const Point &point) { + const byte *tilePointer; + const byte *readPointer; + byte *drawPointer; + Point drawPoint; + int height; + int widthCount = 0; int row; int bg_runct; int fg_runct; int ct; - assert(_init && _tiles_loaded); - if (tile_i >= _tile_ct) { + if (tileNumber >= _tilesCount) { return FAILURE; } /* temporary x clip */ - if (tile_x < 0) { + if (point.x < 0) { return SUCCESS; } /* temporary x clip */ - if (tile_x >= 320 - 32) { + if (point.x >= ds->w - 32) { return SUCCESS; } - tile_p = _tileres_p + _tile_tbl[tile_i].tile_offset; - tile_h = _tile_tbl[tile_i].tile_h; + tilePointer = _tileData + _tilesTable[tileNumber].offset; + height = _tilesTable[tileNumber].height; - read_p = tile_p; - draw_p = (byte *)dst_s->pixels + tile_x + (tile_y * dst_s->pitch); + readPointer = tilePointer; + drawPointer = (byte *)ds->pixels + point.x + (point.y * ds->pitch); - draw_x = tile_x; - draw_y = tile_y; + drawPoint = point; - if (tile_h > SAGA_ISOTILE_BASEHEIGHT) { - draw_y = tile_y - (tile_h - SAGA_ISOTILE_BASEHEIGHT); + if (height > SAGA_ISOTILE_BASEHEIGHT) { + drawPoint.y -= (height - SAGA_ISOTILE_BASEHEIGHT); } // temporary y clip - if (draw_y < 0) { + if (drawPoint.y < 0) { return SUCCESS; } - for (row = 0; row < tile_h; row++) { - draw_p = (byte *)dst_s->pixels + draw_x + ((draw_y + row) * dst_s->pitch); - w_count = 0; + for (row = 0; row < height; row++) { + drawPointer = (byte *)ds->pixels + drawPoint.x + ((drawPoint.y + row) * ds->pitch); + widthCount = 0; // temporary y clip - if ((draw_y + row) >= 137) { + if ((drawPoint.y + row) >= _vm->getDisplayInfo().sceneHeight) { return SUCCESS; } for (;;) { - bg_runct = *read_p++; - w_count += bg_runct; - if (w_count >= SAGA_ISOTILE_WIDTH) { + bg_runct = *readPointer++; + widthCount += bg_runct; + if (widthCount >= SAGA_ISOTILE_WIDTH) { break; } - draw_p += bg_runct; - fg_runct = *read_p++; - w_count += fg_runct; + drawPointer += bg_runct; + fg_runct = *readPointer++; + widthCount += fg_runct; for (ct = 0; ct < fg_runct; ct++) { - *draw_p++ = *read_p++; + *drawPointer++ = *readPointer++; } } } -- cgit v1.2.3