void MapReader1700::read_warp_locations(CMap& map, BinaryFile& mapfile)
{
    for (unsigned short j = 0; j < MAPHEIGHT; j++) {
        for (unsigned short i = 0; i < MAPWIDTH; i++) {
            TileType iType = (TileType)mapfile.read_i32();

            if (iType >= 0 && iType < NUMTILETYPES) {
                map.mapdatatop[i][j].iType = iType;
                map.mapdatatop[i][j].iFlags = g_iTileTypeConversion[iType];
            } else {
                map.mapdatatop[i][j].iType = tile_nonsolid;
                map.mapdatatop[i][j].iFlags = tile_flag_nonsolid;
            }

            map.warpdata[i][j].direction = (WarpEnterDirection)mapfile.read_i32();
            map.warpdata[i][j].connection = (short)mapfile.read_i32();
            map.warpdata[i][j].id = (short)mapfile.read_i32();

            for (short sType = 0; sType < 6; sType += 5)
                map.nospawn[sType][i][j] = mapfile.read_i32() == 0 ? false : true;

            //Copy player no spawn areas into team no spawn areas
            for (short sType = 1; sType < 5; sType++)
                map.nospawn[sType][i][j] = map.nospawn[0][i][j];

        }
    }
}
void MapReader1700::read_platforms(CMap& map, BinaryFile& mapfile, bool fPreview)
{
    map.clearPlatforms();

    //Load moving platforms
    map.iNumPlatforms = (short)mapfile.read_i32();
    map.platforms = new MovingPlatform*[map.iNumPlatforms];

    for (short iPlatform = 0; iPlatform < map.iNumPlatforms; iPlatform++) {
        short iWidth = (short)mapfile.read_i32();
        short iHeight = (short)mapfile.read_i32();

        TilesetTile ** tiles = new TilesetTile*[iWidth];
        MapTile ** types = new MapTile*[iWidth];

        read_platform_tiles(map, mapfile, iWidth, iHeight, tiles, types);

        short iDrawLayer = 2;
        //printf("Layer: %d\n", iDrawLayer);

        short iPathType = 0;
        //printf("PathType: %d\n", iPathType);

        MovingPlatformPath* path = NULL;
        path = read_platform_path_details(mapfile, iPathType, fPreview);
        if (!path)
            continue;

        MovingPlatform * platform = new MovingPlatform(tiles, types, iWidth, iHeight, iDrawLayer, path, fPreview);
        map.platforms[iPlatform] = platform;
        map.platformdrawlayer[iDrawLayer].push_back(platform);
    }
}
void MapReader1802::read_eyecandy(CMap& map, BinaryFile& mapfile)
{
    //Read in eyecandy to use
    //For all layers if the map format supports it
    map.eyecandy[0] = (short)mapfile.read_i32();
    map.eyecandy[1] = (short)mapfile.read_i32();
    map.eyecandy[2] = (short)mapfile.read_i32();
}
void MapReader1800::read_items(CMap& map, BinaryFile& mapfile)
{
    //Load map items (like carryable spikes and springs)
    map.iNumMapItems = mapfile.read_i32();

    for (short j = 0; j < map.iNumMapItems; j++) {
        map.mapitems[j].itype = mapfile.read_i32();
        map.mapitems[j].ix = mapfile.read_i32();
        map.mapitems[j].iy = mapfile.read_i32();
    }
}
void MapReader1800::read_gamemode_settings(CMap& map, BinaryFile& mapfile)
{
    //read mode item locations like flags and race goals
    map.iNumRaceGoals = (short)mapfile.read_i32();
    for (unsigned short j = 0; j < map.iNumRaceGoals; j++) {
        map.racegoallocations[j].x = (short)mapfile.read_i32();
        map.racegoallocations[j].y = (short)mapfile.read_i32();
    }

    map.iNumFlagBases = (short)mapfile.read_i32();
    for (unsigned short j = 0; j < map.iNumFlagBases; j++) {
        map.flagbaselocations[j].x = (short)mapfile.read_i32();
        map.flagbaselocations[j].y = (short)mapfile.read_i32();
    }
}
void MapReader1500::read_tiles(CMap& map, BinaryFile& mapfile)
{
    unsigned short i, j;

    // 2. load map data
    for (j = 0; j < MAPHEIGHT; j++) {
        for (i = 0; i < MAPWIDTH; i++) {
            //Read everything into layer 1
            short iTileID = (short)mapfile.read_i32();

            TilesetTile * tile = &map.mapdata[i][j][1];
            tile->iID = g_tilesetmanager->GetClassicTilesetIndex();
            tile->iCol = iTileID % 32;
            tile->iRow = iTileID / 32;

            TileType iType = g_tilesetmanager->GetClassicTileset()->GetTileType(tile->iCol, tile->iRow);

            if (iType >= 0 && iType < NUMTILETYPES) {
                map.mapdatatop[i][j].iType = iType;
                map.mapdatatop[i][j].iFlags = g_iTileTypeConversion[iType];
            } else {
                map.mapdatatop[i][j].iType = tile_nonsolid;
                map.mapdatatop[i][j].iFlags = tile_flag_nonsolid;
            }

            map.mapdata[i][j][0].iID = TILESETNONE;
            map.mapdata[i][j][2].iID = TILESETNONE;
            map.mapdata[i][j][3].iID = TILESETNONE;
        }
    }

    // 3. load objects data
    for (j = 0; j < MAPHEIGHT; j++) {
        for (i = 0; i < MAPWIDTH; i++) {
            map.objectdata[i][j].iType = (short)mapfile.read_i32();
            if (map.objectdata[i][j].iType == 6)
                map.objectdata[i][j].iType = -1;

            map.objectdata[i][j].fHidden = false;

            if (map.objectdata[i][j].iType == 1) {
                for (short iSetting = 0; iSetting < NUM_BLOCK_SETTINGS; iSetting++)
                    map.objectdata[i][j].iSettings[iSetting] = g_iDefaultPowerupPresets[0][iSetting];
            }
        }
    }
}
void MapReader1800::read_hazards(CMap& map, BinaryFile& mapfile)
{
    //Load map hazards (like fireball strings, rotodiscs, pirhana plants)
    map.iNumMapHazards = mapfile.read_i32();

    for (short iMapHazard = 0; iMapHazard < map.iNumMapHazards; iMapHazard++) {
        map.maphazards[iMapHazard].itype = mapfile.read_i32();
        map.maphazards[iMapHazard].ix = mapfile.read_i32();
        map.maphazards[iMapHazard].iy = mapfile.read_i32();

        for (short iParam = 0; iParam < NUMMAPHAZARDPARAMS; iParam++)
            map.maphazards[iMapHazard].iparam[iParam] = mapfile.read_i32();

        for (short iParam = 0; iParam < NUMMAPHAZARDPARAMS; iParam++)
            map.maphazards[iMapHazard].dparam[iParam] = mapfile.read_float();
    }
}
void MapReader1800::read_switchable_blocks(CMap& map, BinaryFile& mapfile)
{
    //Read switch block state data
    int iNumSwitchBlockData = mapfile.read_i32();
    for (short iBlock = 0; iBlock < iNumSwitchBlockData; iBlock++) {
        short iCol = mapfile.read_i8();
        short iRow = mapfile.read_i8();

        map.objectdata[iCol][iRow].iSettings[0] = mapfile.read_i8();
    }
}
void MapReader1800::read_extra_tiledata(CMap& map, BinaryFile& mapfile)
{
    int iNumExtendedDataBlocks = mapfile.read_i32();

    for (short iBlock = 0; iBlock < iNumExtendedDataBlocks; iBlock++) {
        short iCol = mapfile.read_i8();
        short iRow = mapfile.read_i8();

        short iNumSettings = mapfile.read_i8();
        for (short iSetting = 0; iSetting < iNumSettings; iSetting++)
            map.objectdata[iCol][iRow].iSettings[iSetting] = mapfile.read_i8();
    }
}
示例#10
0
void MapReader1800::read_tileset(BinaryFile& mapfile)
{
    //Load tileset information

    short iNumTilesets = (short)mapfile.read_i32();

    TilesetTranslation * translation = new TilesetTranslation[iNumTilesets];

    iMaxTilesetID = 0; //Figure out how big the translation array needs to be
    for (short iTileset = 0; iTileset < iNumTilesets; iTileset++) {
        short iTilesetID = mapfile.read_i32();
        translation[iTileset].iID = iTilesetID;

        if (iTilesetID > iMaxTilesetID)
            iMaxTilesetID = iTilesetID;

        mapfile.read_string_long(translation[iTileset].szName, 128);
    }

    translationid = new short[iMaxTilesetID + 1];
    tilesetwidths = new short[iMaxTilesetID + 1];
    tilesetheights = new short[iMaxTilesetID + 1];

    for (short iTileset = 0; iTileset < iNumTilesets; iTileset++) {
        short iID = translation[iTileset].iID;
        translationid[iID] = g_tilesetmanager->GetIndexFromName(translation[iTileset].szName);

        if (translationid[iID] == TILESETUNKNOWN) {
            tilesetwidths[iID] = 1;
            tilesetheights[iID] = 1;
        } else {
            tilesetwidths[iID] = g_tilesetmanager->GetTileset(translationid[iID])->GetWidth();
            tilesetheights[iID] = g_tilesetmanager->GetTileset(translationid[iID])->GetHeight();
        }
    }

    delete [] translation;
}
示例#11
0
void MapReader1800::read_warp_locations(CMap& map, BinaryFile& mapfile)
{
    for (unsigned short j = 0; j < MAPHEIGHT; j++) {
        for (unsigned short i = 0; i < MAPWIDTH; i++) {
            TileType iType = (TileType)mapfile.read_i32();

            if (iType >= 0 && iType < NUMTILETYPES) {
                map.mapdatatop[i][j].iType = iType;
                map.mapdatatop[i][j].iFlags = g_iTileTypeConversion[iType];
            } else {
                map.mapdatatop[i][j].iType = tile_nonsolid;
                map.mapdatatop[i][j].iFlags = tile_flag_nonsolid;
            }

            map.warpdata[i][j].direction = (WarpEnterDirection)mapfile.read_i32();
            map.warpdata[i][j].connection = (short)mapfile.read_i32();
            map.warpdata[i][j].id = (short)mapfile.read_i32();

            for (short sType = 0; sType < NUMSPAWNAREATYPES; sType++)
                map.nospawn[sType][i][j] = mapfile.read_bool();

        }
    }
}
示例#12
0
void MapReader1700::read_tiles(CMap& map, BinaryFile& mapfile)
{
    short iClassicTilesetID = g_tilesetmanager->GetIndexFromName("Classic");

    unsigned short i, j, k;
    for (j = 0; j < MAPHEIGHT; j++) {
        for (i = 0; i < MAPWIDTH; i++) {
            for (k = 0; k < MAPLAYERS; k++) {
                short iTileID = (short)mapfile.read_i32();

                TilesetTile * tile = &map.mapdata[i][j][k];

                if (iTileID == TILESETSIZE) {
                    tile->iID = TILESETNONE;
                    tile->iCol = 0;
                    tile->iRow = 0;
                } else {
                    tile->iID = iClassicTilesetID;
                    tile->iCol = iTileID % TILESETWIDTH;
                    tile->iRow = iTileID / TILESETWIDTH;
                }
            }

            map.objectdata[i][j].iType = (short)mapfile.read_i32();
            if (map.objectdata[i][j].iType == 15)
                map.objectdata[i][j].iType = -1;

            map.objectdata[i][j].fHidden = false;

            if (map.objectdata[i][j].iType == 1) {
                for (short iSetting = 0; iSetting < NUM_BLOCK_SETTINGS; iSetting++)
                    map.objectdata[i][j].iSettings[iSetting] = g_iDefaultPowerupPresets[0][iSetting];
            }
        }
    }
}
示例#13
0
void MapReader1700::read_switches(CMap& map, BinaryFile& mapfile)
{
    //Read on/off switches
    for (unsigned short iSwitch = 0; iSwitch < 4; iSwitch++) {
        map.iSwitches[iSwitch] = 1 - (short)mapfile.read_i32();
    }

    //Set all the on/off blocks correctly
    for (unsigned short j = 0; j < MAPHEIGHT; j++) {
        for (unsigned short i = 0; i < MAPWIDTH; i++) {
            if (map.objectdata[i][j].iType >= 11 && map.objectdata[i][j].iType <= 14) {
                map.objectdata[i][j].iSettings[0] = map.iSwitches[map.objectdata[i][j].iType - 11];
            }
        }
    }
}
示例#14
0
void MapReader1800::read_platform_tiles(CMap& map, BinaryFile& mapfile,
    short iWidth, short iHeight, TilesetTile**& tiles, MapTile**& types)
{
    for (short iCol = 0; iCol < iWidth; iCol++) {
        tiles[iCol] = new TilesetTile[iHeight];
        types[iCol] = new MapTile[iHeight];

        for (short iRow = 0; iRow < iHeight; iRow++) {
            TilesetTile * tile = &tiles[iCol][iRow];

            tile->iID = mapfile.read_i8();
            tile->iCol = mapfile.read_i8();
            tile->iRow = mapfile.read_i8();

            if (tile->iID >= 0) {
                if (iMaxTilesetID != -1 && tile->iID > iMaxTilesetID)
                    tile->iID = 0;

                //Make sure the column and row we read in is within the bounds of the tileset
                if (tile->iCol < 0 || (tilesetwidths && tile->iCol >= tilesetwidths[tile->iID]))
                    tile->iCol = 0;

                if (tile->iRow < 0 || (tilesetheights && tile->iRow >= tilesetheights[tile->iID]))
                    tile->iRow = 0;

                //Convert tileset ids into the current game's tileset's ids
                if (translationid)
                    tile->iID = translationid[tile->iID];
            }

            TileType iType = (TileType)mapfile.read_i32();

            if (iType >= 0 && iType < NUMTILETYPES) {
                types[iCol][iRow].iType = iType;
                types[iCol][iRow].iFlags = g_iTileTypeConversion[iType];
            } else {
                types[iCol][iRow].iType = tile_nonsolid;
                types[iCol][iRow].iFlags = tile_flag_nonsolid;
            }
        }
    }
}
示例#15
0
void MapReader1700::read_platform_tiles(CMap& map, BinaryFile& mapfile,
    short iWidth, short iHeight, TilesetTile**& tiles, MapTile**& types)
{
    for (short iCol = 0; iCol < iWidth; iCol++) {
        tiles[iCol] = new TilesetTile[iHeight];
        types[iCol] = new MapTile[iHeight];

        for (short iRow = 0; iRow < iHeight; iRow++) {
            TilesetTile * tile = &tiles[iCol][iRow];

            short iTile = mapfile.read_i32();
            TileType type;

            if (iTile == TILESETSIZE) {
                tile->iID = TILESETNONE;
                tile->iCol = 0;
                tile->iRow = 0;

                type = tile_nonsolid;
            } else {
                tile->iID = g_tilesetmanager->GetClassicTilesetIndex();
                tile->iCol = iTile % TILESETWIDTH;
                tile->iRow = iTile / TILESETWIDTH;

                type = g_tilesetmanager->GetClassicTileset()->GetTileType(tile->iCol, tile->iRow);
            }

            if (type >= 0 && type < NUMTILETYPES) {
                types[iCol][iRow].iType = type;
                types[iCol][iRow].iFlags = g_iTileTypeConversion[type];
            } else {
                map.mapdatatop[iCol][iRow].iType = tile_nonsolid;
                map.mapdatatop[iCol][iRow].iFlags = tile_flag_nonsolid;
            }
        }
    }
}
示例#16
0
bool MapReader1700::read_spawn_areas(CMap& map, BinaryFile& mapfile)
{
    //Read spawn areas
    for (unsigned short i = 0; i < 6; i += 5) {
        map.totalspawnsize[i] = 0;
        map.numspawnareas[i] = (short)mapfile.read_i32();

        if (map.numspawnareas[i] > MAXSPAWNAREAS) {
            cout << endl << " ERROR: Number of spawn areas (" << map.numspawnareas[i]
                 << ") was greater than max allowed (" << MAXSPAWNAREAS << ')'
                 << endl;
            return false;
        }

        for (int m = 0; m < map.numspawnareas[i]; m++) {
            map.spawnareas[i][m].left = (short)mapfile.read_i32();
            map.spawnareas[i][m].top = (short)mapfile.read_i32();
            map.spawnareas[i][m].width = (short)mapfile.read_i32();
            map.spawnareas[i][m].height = (short)mapfile.read_i32();
            map.spawnareas[i][m].size = (short)mapfile.read_i32();

            map.totalspawnsize[i] += map.spawnareas[i][m].size;
        }
    }

    //Copy player spawn areas to team specific spawn areas
    for (short iType = 1; iType < 5; iType++) {
        map.totalspawnsize[iType] = map.totalspawnsize[0];
        map.numspawnareas[iType] = map.numspawnareas[0];

        for (int m = 0; m < map.numspawnareas[0]; m++) {
            map.spawnareas[iType][m].left = map.spawnareas[0][m].left;
            map.spawnareas[iType][m].top = map.spawnareas[0][m].top;
            map.spawnareas[iType][m].width = map.spawnareas[0][m].width;
            map.spawnareas[iType][m].height = map.spawnareas[0][m].height;
            map.spawnareas[iType][m].size = map.spawnareas[0][m].size;
        }
    }

    return true;
}
示例#17
0
bool MapReader1800::read_spawn_areas(CMap& map, BinaryFile& mapfile)
{
    for (unsigned short i = 0; i < NUMSPAWNAREATYPES; i++) {
        map.totalspawnsize[i] = 0;
        map.numspawnareas[i] = (short)mapfile.read_i32();

        if (map.numspawnareas[i] > MAXSPAWNAREAS) {
            cout << endl << " ERROR: Number of spawn areas (" << map.numspawnareas[i]
                 << ") was greater than max allowed (" << MAXSPAWNAREAS << ')'
                 << endl;
            return false;
        }

        for (int m = 0; m < map.numspawnareas[i]; m++) {
            map.spawnareas[i][m].left = (short)mapfile.read_i32();
            map.spawnareas[i][m].top = (short)mapfile.read_i32();
            map.spawnareas[i][m].width = (short)mapfile.read_i32();
            map.spawnareas[i][m].height = (short)mapfile.read_i32();
            map.spawnareas[i][m].size = (short)mapfile.read_i32();

            map.totalspawnsize[i] += map.spawnareas[i][m].size;
        }

        //If no spawn areas were identified, then create one big spawn area
        if (map.totalspawnsize[i] == 0) {
            map.numspawnareas[i] = 1;
            map.spawnareas[i][0].left = 0;
            map.spawnareas[i][0].width = 20;
            map.spawnareas[i][0].top = 1;
            map.spawnareas[i][0].height = 12;
            map.spawnareas[i][0].size = 220;
            map.totalspawnsize[i] = 220;
        }
    }

    return true;
}
示例#18
0
void MapReader1701::read_music_category(CMap& map, BinaryFile& mapfile)
{
    map.musicCategoryID = mapfile.read_i32();
}
示例#19
0
void MapReader1500::read_background(CMap& map, BinaryFile& mapfile)
{
    // Read old background IDs and convert that to a background filename
    map.backgroundID = (short)mapfile.read_i32();
    strcpy(map.szBackgroundFile, g_szBackgroundConversion[map.backgroundID]);
}
示例#20
0
void MapReader1800::read_switches(CMap& map, BinaryFile& mapfile)
{
    // Read the on/off switch state of the four colors (turned on or off)
    for (short iSwitch = 0; iSwitch < 4; iSwitch++)
        map.iSwitches[iSwitch] = (short)mapfile.read_i32();
}