morgan/Grinch-AP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Ocarina of Time (#64)

Browse Source 
* first commit (not including OoT data files yet)

* added some basic options

* rule parser works now at least

* make sure to commit everything this time

* temporary change to BaseClasses for oot

* overworld location graph builds mostly correctly

* adding oot data files

* commenting out world options until later since they only existed to make the RuleParser work

* conversion functions between AP ids and OOT ids

* world graph outputs

* set scrub prices

* itempool generates, entrances connected, way too many options added

* fixed set_rules and set_shop_rules

* temp baseclasses changes

* Reaches the fill step now, old event-based system retained in case the new way breaks

* Song placements and misc fixes everywhere

* temporary changes to make oot work

* changed root exits for AP fill framework

* prevent infinite recursion due to OoT sharing usage of the address field

* age reachability works hopefully, songs are broken again

* working spoiler log generation on beatable-only

* Logic tricks implemented

* need this for logic tricks

* fixed map/compass being placed on Serenade location

* kill unreachable events before filling the world

* add a bunch of utility functions to prepare for rom patching

* move OptionList into generic options

* fixed some silly bugs with OptionList

* properly seed all random behavior (so far)

* ROM generation working

* fix hints trying to get alttp dungeon hint texts

* continue fixing hints

* add oot to network data package

* change item and location IDs to 66000 and 67000 range respectively

* push removed items to precollected items

* fixed various issues with cross-contamination with multiple world generation

* reenable glitched logic (hopefully)

* glitched world files age-check fix

* cleaned up some get_locations calls

* added token shuffle and scrub shuffle, modified some options slightly to make the parsing work

* reenable MQ dungeons

* fix forest mq exception

* made targeting style an option for now, will be cosmetic later

* reminder to move targeting to cosmetics

* some oot option maintenance

* enabled starting time of day

* fixed issue breaking shop slots in multiworld generation

* added "off" option for text shuffle and hints

* shopsanity functionality restored

* change patch file extension

* remove unnecessary utility functions + imports

* update MIT license

* change option to "patch_uncompressed_rom" instead of "compress_rom"

* compliance with new AutoWorld systems

* Kill only internal events, remove non-internal big poe event in code

* re-add the big poe event and handle it correctly

* remove extra method in Range option

* fix typo

* Starting items, starting with consumables option

* do not remove nonexistent item

* move set_shop_rules to after shop items are placed

* some cleanup

* add retries for song placement

* flagged Skull Mask and Mask of Truth as advancement items

* update OoT to use LogicMixin

* Fixed trying to assign starting items from the wrong players

* fixed song retry step

* improved option handling, comments, and starting item replacements

* DefaultOnToggle writes Yes or No to spoiler

* enable compression of output if Compress executable is present

* clean up compression

* check whether (de)compressor exists before running the process

* allow specification of rom path in host.yaml

* check if decompressed file already exists before decompressing again

* fix triforce hunt generation

* rename all the oot state functions with prefix

* OoT: mark triforce pieces as completion goal for triforce hunt

* added overworld and any-dungeon shuffle for dungeon items

* Hide most unshuffled locations and events from the list of locations in spoiler

* build oot option ranges with a generic function instead of defining each separately

* move oot output-type control to host.yaml instead of individual yamls

* implement dungeon song shuffle

* minor improvements to overworld dungeon item shuffle

* remove random ice trap names in shops, mostly to avoid maintaining a massive censor list

* always output patch file to folder, remove option to generate ROM in preparation for removal

* re-add the fix for infinite recursion due to not being light or dark world

* change AP-sendable to Ocarina of Time model, since the triforce piece has some extra code apparently

* oot: remove item_names and location_names

* oot: minor fixes

* oot: comment out ROM patching

* oot: only add CollectionState objects on creation if actually needed

* main entrance shuffle method and entrances-based rules

* fix entrances based rules

* disable master quest and big poe count options for client compatibility

* use get_player_name instead of get_player_names

* fix OptionList

* fix oot options for new option system

* new coop section in oot rom: expand player names to 16 bytes, write AP_PLAYER_NAME at end of PLAYER_NAMES

* fill AP player name in oot rom with 0 instead of 0xDF

* encode player name with ASCII for fixed-width

* revert oot player name array to 8 bytes per name

* remove Pierre location if fast scarecrow is on

* check player name length

* "free_scarecrow" not "fast_scarecrow"

* OoT locations now properly store the AP ID instead of the oot internal ID

* oot __version__ updates in lockstep with AP version

* pull in unmodified oot cosmetic files

* also grab JSONDump since it's needed apparently

* gather extra needed methods, modify imports

* delete cosmetics log, replace all instances of SettingsList with OOTWorld

* cosmetic options working, except for sound effects (due to ear-safe issues)

* SFX, Music, and Fanfare randomization reenabled

* move OoT data files into the worlds folder

* move Compress and Decompress into oot data folder

* Replace get_all_state with custom method to avoid the cache

* OoT ROM: increment item counter before setting incoming item/player values to 0, preventing desync issues

* set data_version to 0

* make Kokiri Sword shuffle off by default

* reenable "Random Choice" for various cosmetic options

* kill Ruto's Letter turnin if open fountain
also fix for shopsanity

* place Buy Goron/Zora Tunic first in shop shuffle

* make ice traps appear as other items instead of breaking generation

* managed to break ice traps on non-major-only

* only handle ice traps if they are on

* fix shopsanity for non-oot games, and write player name instead of player number

* light arrows hint uses player name instead of player number

* Reenable "skip child zelda" option

* fix entrances_based_rules

* fix ganondorf hint if starting with light arrows

* fix dungeonitem shuffle and shopsanity interaction

* remove has_all_of, has_any_of, count_of in BaseClasses, replace usage with has_all, has_any, has_group

* force local giveable item on ZL if skip_child_zelda and shuffle_song_items is any

* keep bosses and bombchu bowling chus out of data package

* revert workaround for infinite recursion and fix it properly

* fix shared shop id caches during patching process

* fix shop text box overflows, as much as possible

* add default oot host.yaml option

* add .apz5, .n64, .z64 to gitignore

* Properly document and name all (functioning) OOT options

* clean up some imports

* remove unnecessary files from oot's data

* fix typo in gitignore

* readd the Compress and Decompress utilities, since they are needed for generation

* cleanup of imports and some minor optimizations

* increase shop offset for item IDs to 0xCB

* remove shop item AP ids entirely

* prevent triforce pieces for other players from being received by yourself

* add "excluded" property to Location

* Hint system adapted and reenabled; hints still unseeded

* make hints deterministic with lists instead of sets

* do not allow hints to point to Light Arrows on non-vanilla bridge

* foreign locations hint as their full name in OoT rather than their region

* checkedLocations now stores hint names by player ID, so that the same location in different worlds can have hints associated

* consolidate versioning in Utils

* ice traps appear as major items rather than any progression item

* set prescription and claim check as defaults for adult trade item settings

* add oot options to playerSettings

* allow case-insensitive logic tricks in yaml

* fix oot shopsanity option formatting

* Write OoT override info even if local item, enabling local checks to show up immediately in the client

* implement CollectionState.can_live_dmg for oot glitched logic

* filter item names for invalid characters when patching shops

* make ice traps appear according to the settings of the world they are shuffled into, rather than the original world

* set hidden-spoiler items and locations with Shop items to events

* make GF carpenters, Gerudo Card, Malon, ZL, and Impa events if the relevant settings are enabled, preventing them from appearing in the client on game start

* Fix oot Glitched and No Logic generation

* fix indenting

* Greatly reduce displayed cosmetic options

* Change oot data version to 1

* add apz5 distribution to webhost

* print player name if an ALttP dungeon contains a good item for OoT world

* delete unneeded commented code

* remove OcarinaSongs import to satisfy lint
This commit is contained in:
espeon65536
2021-09-02 08:35:05 -04:00
committed by GitHub
parent 74c30ce09a
commit 51c38fc628
134 changed files with 80588 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
worlds/oot/data/Decompress/Decompress Normal file
View File

Binary file not shown.

BIN
worlds/oot/data/Decompress/Decompress.exe Normal file
View File

Binary file not shown.

BIN
worlds/oot/data/Decompress/Decompress.out Normal file
View File

Binary file not shown.

BIN
worlds/oot/data/Decompress/Decompress32.exe Normal file
View File

Binary file not shown.

BIN
worlds/oot/data/Decompress/Decompress_ARM64 Normal file
View File

Binary file not shown.

30
worlds/oot/data/Decompress/src/bSwap.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef BSWAP_H
#define BSWAP_H
#include <stdint.h>
#if BYTE_ORDER == LITTLE_ENDIAN
#define bSwap32(x) _bSwap32(x)
#define bSwap16(x) _bSwap16(x)
#elif BYTE_ORDER == BIG_ENDIAN
#define bSwap32(x) (x)
#define bSwap16(x) (x)
#endif
uint32_t _bSwap32(uint32_t a)
{
return( (a & 0x000000FF) << 24 |
(a & 0x0000FF00) << 8 |
(a & 0x00FF0000) >> 8 |
(a & 0xFF000000) >> 24 );
}
uint16_t _bSwap16(uint16_t a)
{
return( (a & 0x00FF) << 8 |
(a & 0xFF00) >> 8 );
}
#endif

175
worlds/oot/data/Decompress/src/crc.c Normal file
View File

@@ -0,0 +1,175 @@
/* snesrc - SNES Recompiler
*
* Copyright notice for this file:
* Copyright (C) 2005 Parasyte
*
* Based on uCON64's N64 checksum algorithm by Andreas Sterbenz
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdio.h>
#include <stdlib.h>
#define ROL(i, b) (((i) << (b)) | ((i) >> (32 - (b))))
#define BYTES2LONG(b) ( (b)[0] << 24 | \
(b)[1] << 16 | \
(b)[2] << 8 | \
(b)[3] )
#define N64_HEADER_SIZE 0x40
#define N64_BC_SIZE (0x1000 - N64_HEADER_SIZE)
#define N64_CRC1 0x10
#define N64_CRC2 0x14
#define CHECKSUM_START 0x00001000
#define CHECKSUM_LENGTH 0x00100000
#define CHECKSUM_CIC6102 0xF8CA4DDC
#define CHECKSUM_CIC6103 0xA3886759
#define CHECKSUM_CIC6105 0xDF26F436
#define CHECKSUM_CIC6106 0x1FEA617A
unsigned int crc_table[256];
void gen_table()
{
uint32_t crc, poly;
int32_t i, j;
poly = 0xEDB88320;
for (i = 0; i < 256; i++) {
crc = i;
for (j = 8; j > 0; j--) {
if (crc & 1) crc = (crc >> 1) ^ poly;
else crc >>= 1;
}
crc_table[i] = crc;
}
}
unsigned int crc32(unsigned char *data, int len)
{
uint32_t crc, i;
crc = ~0;
for (i = 0; i < len; i++)
crc = (crc >> 8) ^ crc_table[(crc ^ data[i]) & 0xFF];
return ~crc;
}
int N64GetCIC(unsigned char *data)
{
switch (crc32(&data[N64_HEADER_SIZE], N64_BC_SIZE)) {
case 0x6170A4A1: return 6101;
case 0x90BB6CB5: return 6102;
case 0x0B050EE0: return 6103;
case 0x98BC2C86: return 6105;
case 0xACC8580A: return 6106;
}
return 0;
}
int N64CalcCRC(unsigned int *crc, unsigned char *data)
{
int32_t bootcode, i;
uint32_t seed, r, d;
uint32_t t1, t2, t3;
uint32_t t4, t5, t6;
switch ((bootcode = N64GetCIC(data))) {
case 6101:
case 6102:
seed = CHECKSUM_CIC6102;
break;
case 6103:
seed = CHECKSUM_CIC6103;
break;
case 6105:
seed = CHECKSUM_CIC6105;
break;
case 6106:
seed = CHECKSUM_CIC6106;
break;
default:
return 0;
}
t1 = t2 = t3 = t4 = t5 = t6 = seed;
i = CHECKSUM_START;
while (i < (CHECKSUM_START + CHECKSUM_LENGTH)) {
d = BYTES2LONG(&data[i]);
if ((t6 + d) < t6) t4++;
t6 += d;
t3 ^= d;
r = ROL(d, (d & 0x1F));
t5 += r;
if (t2 > d) t2 ^= r;
else t2 ^= t6 ^ d;
if (bootcode == 6105) t1 += BYTES2LONG(&data[N64_HEADER_SIZE + 0x0710 + (i & 0xFF)]) ^ d;
else t1 += t5 ^ d;
i += 4;
}
if (bootcode == 6103) {
crc[0] = (t6 ^ t4) + t3;
crc[1] = (t5 ^ t2) + t1;
}
else if (bootcode == 6106) {
crc[0] = (t6 * t4) + t3;
crc[1] = (t5 * t2) + t1;
}
else {
crc[0] = t6 ^ t4 ^ t3;
crc[1] = t5 ^ t2 ^ t1;
}
return 1;
}
void fix_crc (uint8_t* buffer)
{
uint8_t CRC1[4];
uint8_t CRC2[4];
uint32_t crc[2];
uint32_t i;
gen_table();
/* If the CRC calc was successful, do stuff */
if(N64CalcCRC(crc, buffer))
{
for(i = 0; i < 4; i++)
{
CRC1[i] = (crc[0] >> (24-8*i))&0xFF;
CRC2[i] = (crc[1] >> (24-8*i))&0xFF;
}
/* If the CRC1 changed, update it */
if(crc[0] != BYTES2LONG(&buffer[N64_CRC1]))
memcpy(buffer + N64_CRC1, CRC1, 4);
/* If the CRC2 changed, update it */
if (crc[1] != BYTES2LONG(&buffer[N64_CRC2]))
memcpy(buffer + N64_CRC2, CRC2, 4);
}
}

259
worlds/oot/data/Decompress/src/decompressor.c Normal file
View File

@@ -0,0 +1,259 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "crc.c"
#include "bSwap.h"
#define UINTSIZE 0x01000000
#define COMPSIZE 0x02000000
#define DCMPSIZE 0x04000000
/* Structs */
typedef struct
{
uint32_t startV; /* Start Virtual Address */
uint32_t endV; /* End Virtual Address */
uint32_t startP; /* Start Physical Address */
uint32_t endP; /* End Phycical Address */
}
table_t;
/* Functions */
void decompress(uint8_t*, uint8_t*, int32_t);
table_t getTabEnt(uint32_t);
void setTabEnt(uint32_t, table_t);
void loadROM(char*);
int32_t findTable();
/* Globals */
uint8_t* inROM;
uint8_t* outROM;
uint32_t* inTable;
uint32_t* outTable;
int main(int argc, char** argv)
{
FILE* outFile;
int32_t tabStart, tabSize, tabCount;
int32_t size, i;
table_t tab, tempTab;
char* name;
/* Check arguments */
if(argc < 2 || argc > 3)
{
fprintf(stderr, "Usage: %s [Input ROM] <Output ROM>\n", argv[0]);
exit(1);
}
/* If no output file was specified, make one */
/* Add "-decomp.z64" to the end of the input file */
if(argc != 3)
{
size = strlen(argv[1]);
name = malloc(size + 7);
strcpy(name, argv[1]);
for(i = size; i >= 0; i--)
{
if(name[i] == '.')
{
name[i] = '\0';
break;
}
}
strcat(name, "-decomp.z64");
}
else
name = argv[2];
inROM = malloc(DCMPSIZE);
outROM = malloc(DCMPSIZE);
/* Load the ROM into inROM and outROM */
loadROM(argv[1]);
/* Find table offsets */
tabStart = findTable();
inTable = (uint32_t*)(inROM + tabStart);
outTable = (uint32_t*)(outROM + tabStart);
tab = getTabEnt(2);
tabSize = tab.endV - tab.startV;
tabCount = tabSize / 16;
/* Set everything past the table in outROM to 0 */
memset((uint8_t*)(outROM) + tab.endV, 0, DCMPSIZE - tab.endV);
for(i = 3; i < tabCount; i++)
{
tempTab = getTabEnt(i);
size = tempTab.endV - tempTab.startV;
/* dmaTable will have 0xFFFFFFFF if file doesn't exist */
if(tempTab.startP >= DCMPSIZE || tempTab.endP == 0xFFFFFFFF)
continue;
/* Copy if not compressed, decompress otherwise */
if(tempTab.endP == 0x00000000)
memcpy((void*)outROM + tempTab.startV, (void*)inROM + tempTab.startP, size);
else
decompress((void*)inROM + tempTab.startP, (void*)outROM + tempTab.startV, size);
/* Clean up outROM's table */
tempTab.startP = tempTab.startV;
tempTab.endP = 0x00000000;
setTabEnt(i, tempTab);
}
/* Fix the CRC */
fix_crc(outROM);
/* Write the new ROM */
outFile = fopen(name, "wb");
fwrite(outROM, sizeof(uint32_t), UINTSIZE, outFile);
fclose(outFile);
free(outROM);
free(inROM);
if(argc != 3)
free(name);
return(0);
}
int32_t findTable()
{
int32_t i, temp;
uint32_t* tempROM;
tempROM = (uint32_t*)inROM;
/* Start at the end of the makerom (0x10600000) */
/* Look for dma entry for the makeom */
/* Should work for all Zelda64 titles */
for(i = 1048; i+4 < UINTSIZE; i += 4)
{
if(tempROM[i] == 0x00000000)
if(tempROM[i+1] == 0x60100000)
return(i * 4);
}
fprintf(stderr, "Error: Couldn't find table\n");
exit(1);
}
void loadROM(char* name)
{
uint32_t size, i;
uint16_t* tempROM;
FILE* romFile;
/* Open file, make sure it exists */
romFile = fopen(name, "rb");
if(romFile == NULL)
{
perror(name);
exit(1);
}
/* Find size of file */
fseek(romFile, 0, SEEK_END);
size = ftell(romFile);
fseek(romFile, 0, SEEK_SET);
/* If it's not the right size, exit */
if(size != COMPSIZE)
{
fprintf(stderr, "Error, %s is not the correct size", name);
exit(1);
}
/* Read to inROM, close romFile, and copy to outROM */
fread(inROM, sizeof(char), size, romFile);
tempROM = (uint16_t*)inROM;
fclose(romFile);
/* bSwap16 if needed */
if (inROM[0] == 0x37)
for (i = 0; i < UINTSIZE; i++)
tempROM[i] = bSwap16(tempROM[i]);
memcpy(outROM, inROM, size);
}
table_t getTabEnt(uint32_t i)
{
table_t tab;
/* First 32 bytes are VROM start address, next 32 are VROM end address */
/* Next 32 bytes are Physical start address, last 32 are Physical end address */
tab.startV = bSwap32(inTable[i*4] );
tab.endV = bSwap32(inTable[(i*4)+1]);
tab.startP = bSwap32(inTable[(i*4)+2]);
tab.endP = bSwap32(inTable[(i*4)+3]);
return(tab);
}
void setTabEnt(uint32_t i, table_t tab)
{
/* First 32 bytes are VROM start address, next 32 are VROM end address */
/* Next 32 bytes are Physical start address, last 32 are Physical end address */
outTable[i*4] = bSwap32(tab.startV);
outTable[(i*4)+1] = bSwap32(tab.endV);
outTable[(i*4)+2] = bSwap32(tab.startP);
outTable[(i*4)+3] = bSwap32(tab.endP);
}
void decompress(uint8_t* source, uint8_t* decomp, int32_t decompSize)
{
uint32_t srcPlace = 0, dstPlace = 0;
uint32_t i, dist, copyPlace, numBytes;
uint8_t codeByte, byte1, byte2;
uint8_t bitCount = 0;
source += 0x10;
while(dstPlace < decompSize)
{
/* If there are no more bits to test, get a new byte */
if(!bitCount)
{
codeByte = source[srcPlace++];
bitCount = 8;
}
/* If bit 7 is a 1, just copy 1 byte from source to destination */
/* Else do some decoding */
if(codeByte & 0x80)
{
decomp[dstPlace++] = source[srcPlace++];
}
else
{
/* Get 2 bytes from source */
byte1 = source[srcPlace++];
byte2 = source[srcPlace++];
/* Calculate distance to move in destination */
/* And the number of bytes to copy */
dist = ((byte1 & 0xF) << 8) | byte2;
copyPlace = dstPlace - (dist + 1);
numBytes = byte1 >> 4;
/* Do more calculations on the number of bytes to copy */
if(!numBytes)
numBytes = source[srcPlace++] + 0x12;
else
numBytes += 2;
/* Copy data from a previous point in destination */
/* to current point in destination */
for(i = 0; i < numBytes; i++)
decomp[dstPlace++] = decomp[copyPlace++];
}
/* Set up for the next read cycle */
codeByte = codeByte << 1;
bitCount--;
}
}