839 lines
44 KiB
Python
839 lines
44 KiB
Python
from enum import Enum
|
|
from logging import exception
|
|
from typing import Any, Callable, List, Sequence
|
|
import random
|
|
import typing
|
|
from BaseClasses import Location
|
|
from .Item import Item, ItemType, lookup_id_to_name
|
|
from .Location import LocationType
|
|
from .Region import IReward, RewardType, SMRegion, Z3Region
|
|
from .Regions.Zelda.EasternPalace import EasternPalace
|
|
from .Regions.Zelda.DesertPalace import DesertPalace
|
|
from .Regions.Zelda.TowerOfHera import TowerOfHera
|
|
from .Regions.Zelda.PalaceOfDarkness import PalaceOfDarkness
|
|
from .Regions.Zelda.SwampPalace import SwampPalace
|
|
from .Regions.Zelda.SkullWoods import SkullWoods
|
|
from .Regions.Zelda.ThievesTown import ThievesTown
|
|
from .Regions.Zelda.IcePalace import IcePalace
|
|
from .Regions.Zelda.MiseryMire import MiseryMire
|
|
from .Regions.Zelda.TurtleRock import TurtleRock
|
|
from .Regions.Zelda.GanonsTower import GanonsTower
|
|
from .Regions.SuperMetroid.Brinstar.Kraid import Kraid
|
|
from .Regions.SuperMetroid.WreckedShip import WreckedShip
|
|
from .Regions.SuperMetroid.Maridia.Inner import Inner
|
|
from .Regions.SuperMetroid.NorfairLower.East import East
|
|
from .Text.StringTable import StringTable
|
|
|
|
from .World import World
|
|
from .Config import Config, OpenTourian, Goal
|
|
from .Text.Texts import Texts
|
|
from .Text.Dialog import Dialog
|
|
|
|
class KeycardPlaque:
|
|
Level1 = 0xe0
|
|
Level2 = 0xe1
|
|
Boss = 0xe2
|
|
Null = 0x00
|
|
Zero = 0xe3
|
|
One = 0xe4
|
|
Two = 0xe5
|
|
Three = 0xe6
|
|
Four = 0xe7
|
|
|
|
class KeycardDoors:
|
|
Left = 0xd414
|
|
Right = 0xd41a
|
|
Up = 0xd420
|
|
Down = 0xd426
|
|
BossLeft = 0xc842
|
|
BossRight = 0xc848
|
|
|
|
|
|
class KeycardEvents:
|
|
CrateriaLevel1 = 0x0000
|
|
CrateriaLevel2 = 0x0100
|
|
CrateriaBoss = 0x0200
|
|
BrinstarLevel1 = 0x0300
|
|
BrinstarLevel2 = 0x0400
|
|
BrinstarBoss = 0x0500
|
|
NorfairLevel1 = 0x0600
|
|
NorfairLevel2 = 0x0700
|
|
NorfairBoss = 0x0800
|
|
MaridiaLevel1 = 0x0900
|
|
MaridiaLevel2 = 0x0a00
|
|
MaridiaBoss = 0x0b00
|
|
WreckedShipLevel1 = 0x0c00
|
|
WreckedShipBoss = 0x0d00
|
|
LowerNorfairLevel1 = 0x0e00
|
|
LowerNorfairBoss = 0x0f00
|
|
|
|
class DropPrize(Enum):
|
|
Heart = 0xD8
|
|
Green = 0xD9
|
|
Blue = 0xDA
|
|
Red = 0xDB
|
|
Bomb1 = 0xDC
|
|
Bomb4 = 0xDD
|
|
Bomb8 = 0xDE
|
|
Magic = 0xDF
|
|
FullMagic = 0xE0
|
|
Arrow5 = 0xE1
|
|
Arrow10 = 0xE2
|
|
Fairy = 0xE3
|
|
|
|
class Patch:
|
|
Major = 11
|
|
Minor = 3
|
|
Patch = 1
|
|
allWorlds: List[World]
|
|
myWorld: World
|
|
seedGuid: str
|
|
seed: int
|
|
rnd: random.Random
|
|
patches: Sequence[Any]
|
|
stringTable: StringTable
|
|
silversWorldID: int
|
|
|
|
def __init__(self, myWorld: World, allWorlds: List[World], seedGuid: str, seed: int, rnd: random.Random, playerNames: List[str], silversWorldID: int):
|
|
self.myWorld = myWorld
|
|
self.allWorlds = allWorlds
|
|
self.seedGuid = seedGuid
|
|
self.seed = seed
|
|
self.rnd = rnd
|
|
self.playerNames = playerNames
|
|
self.playerIDToNames = {id:name for name, id in playerNames.items()}
|
|
self.silversWorldID = silversWorldID
|
|
|
|
def Create(self, config: Config):
|
|
self.stringTable = StringTable()
|
|
self.patches = []
|
|
self.title = ""
|
|
|
|
self.WriteMedallions()
|
|
self.WriteRewards()
|
|
self.WriteDungeonMusic(config.Keysanity)
|
|
|
|
self.WriteDiggingGameRng()
|
|
|
|
self.WritePrizeShuffle(self.myWorld.WorldState.DropPrizes)
|
|
|
|
self.WriteRemoveEquipmentFromUncle( self.myWorld.GetLocation("Link's Uncle").APLocation.item.item if
|
|
self.myWorld.GetLocation("Link's Uncle").APLocation.item.game == "SMZ3" else
|
|
Item(ItemType.Something))
|
|
|
|
self.WriteGanonInvicible(config.Goal)
|
|
self.WritePreOpenPyramid(config.Goal)
|
|
self.WriteCrystalsNeeded(self.myWorld.TowerCrystals, self.myWorld.GanonCrystals, config.Goal)
|
|
self.WriteBossesNeeded(self.myWorld.TourianBossTokens)
|
|
self.WriteRngBlock()
|
|
|
|
self.WriteSaveAndQuitFromBossRoom()
|
|
self.WriteWorldOnAgahnimDeath()
|
|
|
|
self.WriteTexts(config)
|
|
|
|
self.WriteSMLocations([loc for region in self.myWorld.Regions for loc in region.Locations if isinstance(region, SMRegion)])
|
|
self.WriteZ3Locations([loc for region in self.myWorld.Regions for loc in region.Locations if isinstance(region, Z3Region)])
|
|
|
|
self.WriteStringTable()
|
|
|
|
self.WriteSMKeyCardDoors()
|
|
self.WriteZ3KeysanityFlags()
|
|
|
|
self.WritePlayerNames()
|
|
self.WriteSeedData()
|
|
self.WriteGameTitle()
|
|
self.WriteCommonFlags()
|
|
|
|
return {patch[0]:patch[1] for patch in self.patches}
|
|
|
|
def WriteMedallions(self):
|
|
from .WorldState import Medallion
|
|
turtleRock = next(region for region in self.myWorld.Regions if isinstance(region, TurtleRock))
|
|
miseryMire = next(region for region in self.myWorld.Regions if isinstance(region, MiseryMire))
|
|
|
|
turtleRockAddresses = [0x308023, 0xD020, 0xD0FF, 0xD1DE ]
|
|
miseryMireAddresses = [ 0x308022, 0xCFF2, 0xD0D1, 0xD1B0 ]
|
|
|
|
if turtleRock.Medallion == Medallion.Bombos:
|
|
turtleRockValues = [0x00, 0x51, 0x10, 0x00]
|
|
elif turtleRock.Medallion == Medallion.Ether:
|
|
turtleRockValues = [0x01, 0x51, 0x18, 0x00]
|
|
elif turtleRock.Medallion == Medallion.Quake:
|
|
turtleRockValues = [0x02, 0x14, 0xEF, 0xC4]
|
|
else:
|
|
raise exception(f"Tried using {turtleRock.Medallion} in place of Turtle Rock medallion")
|
|
|
|
if miseryMire.Medallion == Medallion.Bombos:
|
|
miseryMireValues = [0x00, 0x51, 0x00, 0x00]
|
|
elif miseryMire.Medallion == Medallion.Ether:
|
|
miseryMireValues = [0x01, 0x13, 0x9F, 0xF1]
|
|
elif miseryMire.Medallion == Medallion.Quake:
|
|
miseryMireValues = [0x02, 0x51, 0x08, 0x00]
|
|
else:
|
|
raise exception(f"Tried using {miseryMire.Medallion} in place of Misery Mire medallion")
|
|
|
|
self.patches += [(Snes(addr), [value]) for addr, value in zip(turtleRockAddresses, turtleRockValues)]
|
|
self.patches += [(Snes(addr), [value]) for addr, value in zip(miseryMireAddresses, miseryMireValues)]
|
|
|
|
def WriteRewards(self):
|
|
crystalsBlue = [ 1, 2, 3, 4, 7 ]
|
|
self.rnd.shuffle(crystalsBlue)
|
|
crystalsRed = [ 5, 6 ]
|
|
self.rnd.shuffle(crystalsRed)
|
|
crystalRewards = crystalsBlue + crystalsRed
|
|
|
|
pendantsGreen = [ 1 ]
|
|
pendantsBlueRed = [ 2, 3 ]
|
|
self.rnd.shuffle(pendantsBlueRed)
|
|
pendantRewards = pendantsGreen + pendantsBlueRed
|
|
|
|
bossTokens = [ 1, 2, 3, 4 ]
|
|
|
|
regions = [region for region in self.myWorld.Regions if isinstance(region, IReward)]
|
|
crystalRegions = [region for region in regions if region.Reward == RewardType.CrystalBlue] + [region for region in regions if region.Reward == RewardType.CrystalRed]
|
|
pendantRegions = [region for region in regions if region.Reward == RewardType.PendantGreen] + [region for region in regions if region.Reward == RewardType.PendantNonGreen]
|
|
bossRegions = [region for region in regions if region.Reward == RewardType.BossTokenKraid] + \
|
|
[region for region in regions if region.Reward == RewardType.BossTokenPhantoon] + \
|
|
[region for region in regions if region.Reward == RewardType.BossTokenDraygon] + \
|
|
[region for region in regions if region.Reward == RewardType.BossTokenRidley]
|
|
|
|
self.patches += self.RewardPatches(crystalRegions, crystalRewards, self.CrystalValues)
|
|
self.patches += self.RewardPatches(pendantRegions, pendantRewards, self.PendantValues)
|
|
self.patches += self.RewardPatches(bossRegions, bossTokens, self.BossTokenValues)
|
|
|
|
def RewardPatches(self, regions: List[IReward], rewards: List[int], rewardValues: Callable):
|
|
addresses = [self.RewardAddresses(region) for region in regions]
|
|
values = [rewardValues(reward) for reward in rewards]
|
|
associations = zip(addresses, values)
|
|
return [(Snes(i), [b]) for association in associations for i,b in zip(association[0], association[1])]
|
|
|
|
def RewardAddresses(self, region: IReward):
|
|
regionType = {
|
|
EasternPalace : [ 0x2A09D, 0xABEF8, 0xABEF9, 0x308052, 0x30807C, 0x1C6FE, 0x30D100],
|
|
DesertPalace : [ 0x2A09E, 0xABF1C, 0xABF1D, 0x308053, 0x308078, 0x1C6FF, 0x30D101 ],
|
|
TowerOfHera : [ 0x2A0A5, 0xABF0A, 0xABF0B, 0x30805A, 0x30807A, 0x1C706, 0x30D102 ],
|
|
PalaceOfDarkness : [ 0x2A0A1, 0xABF00, 0xABF01, 0x308056, 0x30807D, 0x1C702, 0x30D103 ],
|
|
SwampPalace : [ 0x2A0A0, 0xABF6C, 0xABF6D, 0x308055, 0x308071, 0x1C701, 0x30D104 ],
|
|
SkullWoods : [ 0x2A0A3, 0xABF12, 0xABF13, 0x308058, 0x30807B, 0x1C704, 0x30D105 ],
|
|
ThievesTown : [ 0x2A0A6, 0xABF36, 0xABF37, 0x30805B, 0x308077, 0x1C707, 0x30D106 ],
|
|
IcePalace : [ 0x2A0A4, 0xABF5A, 0xABF5B, 0x308059, 0x308073, 0x1C705, 0x30D107 ],
|
|
MiseryMire : [ 0x2A0A2, 0xABF48, 0xABF49, 0x308057, 0x308075, 0x1C703, 0x30D108 ],
|
|
TurtleRock : [ 0x2A0A7, 0xABF24, 0xABF25, 0x30805C, 0x308079, 0x1C708, 0x30D109 ],
|
|
Kraid : [ 0xF26002, 0xF26004, 0xF26005, 0xF26000, 0xF26006, 0xF26007, 0x82FD36 ],
|
|
WreckedShip : [ 0xF2600A, 0xF2600C, 0xF2600D, 0xF26008, 0xF2600E, 0xF2600F, 0x82FE26 ],
|
|
Inner : [ 0xF26012, 0xF26014, 0xF26015, 0xF26010, 0xF26016, 0xF26017, 0x82FE76 ],
|
|
East : [ 0xF2601A, 0xF2601C, 0xF2601D, 0xF26018, 0xF2601E, 0xF2601F, 0x82FDD6 ]
|
|
}
|
|
|
|
result = regionType.get(type(region), None)
|
|
if result is None:
|
|
raise exception(f"Region {region} should not be a dungeon reward region")
|
|
else:
|
|
return result
|
|
|
|
def CrystalValues(self, crystal: int):
|
|
crystalMap = {
|
|
1 : [ 0x02, 0x34, 0x64, 0x40, 0x7F, 0x06, 0x10 ],
|
|
2 : [ 0x10, 0x34, 0x64, 0x40, 0x79, 0x06, 0x10 ],
|
|
3 : [ 0x40, 0x34, 0x64, 0x40, 0x6C, 0x06, 0x10 ],
|
|
4 : [ 0x20, 0x34, 0x64, 0x40, 0x6D, 0x06, 0x10 ],
|
|
5 : [ 0x04, 0x32, 0x64, 0x40, 0x6E, 0x06, 0x11 ],
|
|
6 : [ 0x01, 0x32, 0x64, 0x40, 0x6F, 0x06, 0x11 ],
|
|
7 : [ 0x08, 0x34, 0x64, 0x40, 0x7C, 0x06, 0x10 ],
|
|
}
|
|
result = crystalMap.get(crystal, None)
|
|
if result is None:
|
|
raise exception(f"Tried using {crystal} as a crystal number")
|
|
else:
|
|
return result
|
|
|
|
def PendantValues(self, pendant: int):
|
|
pendantMap = {
|
|
1 : [ 0x04, 0x38, 0x62, 0x00, 0x69, 0x01, 0x12 ],
|
|
2 : [ 0x01, 0x32, 0x60, 0x00, 0x69, 0x03, 0x14 ],
|
|
3 : [ 0x02, 0x34, 0x60, 0x00, 0x69, 0x02, 0x13 ]
|
|
}
|
|
result = pendantMap.get(pendant, None)
|
|
if result is None:
|
|
raise exception(f"Tried using {pendant} as a pendant number")
|
|
else:
|
|
return result
|
|
|
|
def BossTokenValues(self, token: int):
|
|
tokenMap = {
|
|
1 : [ 0x01, 0x38, 0x40, 0x80, 0x69, 0x80, 0x15 ],
|
|
2 : [ 0x02, 0x34, 0x42, 0x80, 0x69, 0x81, 0x16 ],
|
|
3 : [ 0x04, 0x34, 0x44, 0x80, 0x69, 0x82, 0x17 ],
|
|
4 : [ 0x08, 0x32, 0x46, 0x80, 0x69, 0x83, 0x18 ]
|
|
}
|
|
result = tokenMap.get(token, None)
|
|
if result is None:
|
|
raise exception(f"Tried using {token} as a boss token number")
|
|
else:
|
|
return result
|
|
|
|
def WriteSMLocations(self, locations: List[Location]):
|
|
def GetSMItemPLM(location:Location):
|
|
itemMap = {
|
|
ItemType.ETank : 0xEED7,
|
|
ItemType.Missile : 0xEEDB,
|
|
ItemType.Super : 0xEEDF,
|
|
ItemType.PowerBomb : 0xEEE3,
|
|
ItemType.Bombs : 0xEEE7,
|
|
ItemType.Charge : 0xEEEB,
|
|
ItemType.Ice : 0xEEEF,
|
|
ItemType.HiJump : 0xEEF3,
|
|
ItemType.SpeedBooster : 0xEEF7,
|
|
ItemType.Wave : 0xEEFB,
|
|
ItemType.Spazer : 0xEEFF,
|
|
ItemType.SpringBall : 0xEF03,
|
|
ItemType.Varia : 0xEF07,
|
|
ItemType.Plasma : 0xEF13,
|
|
ItemType.Grapple : 0xEF17,
|
|
ItemType.Morph : 0xEF23,
|
|
ItemType.ReserveTank : 0xEF27,
|
|
ItemType.Gravity : 0xEF0B,
|
|
ItemType.XRay : 0xEF0F,
|
|
ItemType.SpaceJump : 0xEF1B,
|
|
ItemType.ScrewAttack : 0xEF1F
|
|
}
|
|
plmId = 0xEFE0 if self.myWorld.Config.Multiworld else \
|
|
itemMap.get(location.APLocation.item.item.Type, 0xEFE0)
|
|
if (plmId == 0xEFE0):
|
|
plmId += 4 if location.Type == LocationType.Chozo else 8 if location.Type == LocationType.Hidden else 0
|
|
else:
|
|
plmId += 0x54 if location.Type == LocationType.Chozo else 0xA8 if location.Type == LocationType.Hidden else 0
|
|
return plmId
|
|
|
|
for location in locations:
|
|
if (self.myWorld.Config.Multiworld):
|
|
self.patches.append((Snes(location.Address), getWordArray(GetSMItemPLM(location))))
|
|
self.patches.append(self.ItemTablePatch(location, self.GetZ3ItemId(location)))
|
|
else:
|
|
plmId = GetSMItemPLM(location)
|
|
self.patches.append((Snes(location.Address), getWordArray(plmId)))
|
|
if (plmId >= 0xEFE0):
|
|
self.patches.append((Snes(location.Address + 5), [self.GetZ3ItemId(location)]))
|
|
|
|
def WriteZ3Locations(self, locations: List[Location]):
|
|
for location in locations:
|
|
if (location.Type == LocationType.HeraStandingKey):
|
|
self.patches.append((Snes(0x9E3BB), [0xEB]))
|
|
elif (location.Type in [LocationType.Pedestal, LocationType.Ether, LocationType.Bombos]):
|
|
text = Texts.ItemTextbox(location.APLocation.item.item if location.APLocation.item.game == "SMZ3" else Item(ItemType.Something))
|
|
if (location.Type == LocationType.Pedestal):
|
|
self.stringTable.SetPedestalText(text)
|
|
elif (location.Type == LocationType.Ether):
|
|
self.stringTable.SetEtherText(text)
|
|
elif (location.Type == LocationType.Bombos):
|
|
self.stringTable.SetBombosText(text)
|
|
|
|
if (self.myWorld.Config.Multiworld):
|
|
self.patches.append((Snes(location.Address), [(location.Id - 256)]))
|
|
self.patches.append(self.ItemTablePatch(location, self.GetZ3ItemId(location)))
|
|
else:
|
|
self.patches.append((Snes(location.Address), [self.GetZ3ItemId(location)]))
|
|
|
|
def GetZ3ItemId(self, location: Location):
|
|
if (location.APLocation.item.game == "SMZ3"):
|
|
item = location.APLocation.item.item
|
|
itemDungeon = None
|
|
if item.IsKey():
|
|
itemDungeon = ItemType.Key
|
|
elif item.IsBigKey():
|
|
itemDungeon = ItemType.BigKey
|
|
elif item.IsMap():
|
|
itemDungeon = ItemType.Map
|
|
elif item.IsCompass():
|
|
itemDungeon = ItemType.Compass
|
|
|
|
value = item.Type if location.Type == LocationType.NotInDungeon or \
|
|
not (item.IsDungeonItem() and location.Region.IsRegionItem(item) and item.World == self.myWorld) else itemDungeon
|
|
|
|
return value.value
|
|
elif (location.APLocation.item.game == "A Link to the Past"):
|
|
if location.APLocation.item.code + 84000 in lookup_id_to_name:
|
|
ALTTPBottleContentCodeToSMZ3ItemCode = {
|
|
ItemType.RedContent.value: ItemType.BottleWithRedPotion.value,
|
|
ItemType.GreenContent.value: ItemType.BottleWithGreenPotion.value,
|
|
ItemType.BlueContent.value: ItemType.BottleWithBluePotion.value,
|
|
ItemType.BeeContent.value: ItemType.BottleWithBee.value,
|
|
}
|
|
return ALTTPBottleContentCodeToSMZ3ItemCode.get(location.APLocation.item.code, location.APLocation.item.code)
|
|
else:
|
|
return ItemType.Something.value
|
|
elif (location.APLocation.item.game == "Super Metroid"):
|
|
SMNameToSMZ3Code = {
|
|
"Energy Tank": ItemType.ETank, "Missile": ItemType.Missile, "Super Missile": ItemType.Super,
|
|
"Power Bomb": ItemType.PowerBomb, "Bomb": ItemType.Bombs, "Charge Beam": ItemType.Charge,
|
|
"Ice Beam": ItemType.Ice, "Hi-Jump Boots": ItemType.HiJump, "Speed Booster": ItemType.SpeedBooster,
|
|
"Wave Beam": ItemType.Wave, "Spazer": ItemType.Spazer, "Spring Ball": ItemType.SpringBall,
|
|
"Varia Suit": ItemType.Varia, "Plasma Beam": ItemType.Plasma, "Grappling Beam": ItemType.Grapple,
|
|
"Morph Ball": ItemType.Morph, "Reserve Tank": ItemType.ReserveTank, "Gravity Suit": ItemType.Gravity,
|
|
"X-Ray Scope": ItemType.XRay, "Space Jump": ItemType.SpaceJump, "Screw Attack": ItemType.ScrewAttack,
|
|
"Nothing": ItemType.Something, "No Energy": ItemType.Something, "Generic": ItemType.Something
|
|
}
|
|
return SMNameToSMZ3Code.get(location.APLocation.item.name, ItemType.Something).value
|
|
else:
|
|
return ItemType.Something.value
|
|
|
|
def ItemTablePatch(self, location: Location, itemId: int):
|
|
itemtype = 0 if location.APLocation.item.player == location.Region.world.Id else 1
|
|
owner = location.APLocation.item.player if location.APLocation.item.player < 256 else 0
|
|
return (0x386000 + (location.Id * 8), getWordArray(itemtype) + getWordArray(itemId) + getWordArray(owner))
|
|
|
|
def WriteDungeonMusic(self, keysanity: bool):
|
|
if (not keysanity):
|
|
regions = [region for region in self.myWorld.Regions if isinstance(region, Z3Region) and isinstance(region, IReward) and
|
|
region.Reward != None and region.Reward != RewardType.Agahnim]
|
|
pendantRegions = [region for region in regions if region.Reward in [RewardType.PendantGreen, RewardType.PendantNonGreen]]
|
|
crystalRegions = [region for region in regions if region.Reward in [RewardType.CrystalBlue, RewardType.CrystalRed]]
|
|
music = [0x11 if (region.Reward == RewardType.PendantGreen or region.Reward == RewardType.PendantNonGreen) else 0x16 for region in regions]
|
|
self.patches += self.MusicPatches(regions, music)
|
|
|
|
#IEnumerable<byte> RandomDungeonMusic() {
|
|
# while (true) yield return rnd.Next(2) == 0 ? (byte)0x11 : (byte)0x16;
|
|
#}
|
|
|
|
def MusicPatches(self, regions: List[IReward], music: List[int]):
|
|
addresses = [self.MusicAddresses(region) for region in regions]
|
|
associations = zip(addresses, music)
|
|
return [(Snes(i), [association[1]]) for association in associations for i in association[0]]
|
|
|
|
def MusicAddresses(self, region: IReward):
|
|
regionMap = {
|
|
EasternPalace : [ 0x2D59A ],
|
|
DesertPalace : [ 0x2D59B, 0x2D59C, 0x2D59D, 0x2D59E ],
|
|
TowerOfHera : [ 0x2D5C5, 0x2907A, 0x28B8C ],
|
|
PalaceOfDarkness : [ 0x2D5B8 ],
|
|
SwampPalace : [ 0x2D5B7 ],
|
|
SkullWoods : [ 0x2D5BA, 0x2D5BB, 0x2D5BC, 0x2D5BD, 0x2D608, 0x2D609, 0x2D60A, 0x2D60B ],
|
|
ThievesTown : [ 0x2D5C6 ],
|
|
IcePalace : [ 0x2D5BF ],
|
|
MiseryMire : [ 0x2D5B9 ],
|
|
TurtleRock : [ 0x2D5C7, 0x2D5A7, 0x2D5AA, 0x2D5AB ],
|
|
}
|
|
result = regionMap.get(type(region), None)
|
|
if result is None:
|
|
raise exception(f"Region {region} should not be a dungeon music region")
|
|
else:
|
|
return result
|
|
|
|
def WritePrizeShuffle(self, dropPrizes):
|
|
self.patches.append((Snes(0x6FA78), [e.value for e in dropPrizes.Packs]))
|
|
self.patches.append((Snes(0x1DFBD4), [e.value for e in dropPrizes.TreePulls]))
|
|
self.patches.append((Snes(0x6A9C8), [dropPrizes.CrabContinous.value]))
|
|
self.patches.append((Snes(0x6A9C4), [dropPrizes.CrabFinal.value]))
|
|
self.patches.append((Snes(0x6F993), [dropPrizes.Stun.value]))
|
|
self.patches.append((Snes(0x1D82CC), [dropPrizes.Fish.value]))
|
|
|
|
self.patches += self.EnemyPrizePackDistribution()
|
|
|
|
#/* Pack drop chance */
|
|
#/* Normal difficulty is 50%. 0 => 100%, 1 => 50%, 3 => 25% */
|
|
nrPacks = 7
|
|
probability = 1
|
|
self.patches.append((Snes(0x6FA62), [probability] * nrPacks))
|
|
|
|
def EnemyPrizePackDistribution(self):
|
|
(prizePacks, duplicatePacks) = self.EnemyPrizePacks()
|
|
|
|
n = sum(len(x[1]) for x in prizePacks)
|
|
randomization = self.PrizePackRandomization(n, 1)
|
|
patches = []
|
|
for prizepack in prizePacks:
|
|
(packs, randomization) = SplitOff(randomization, len(prizepack[1]))
|
|
patches.append((prizepack[0], [(b | p) for b,p in zip(prizepack[1], packs)]))
|
|
|
|
duplicates = [(d[1], p[1])
|
|
for d in duplicatePacks
|
|
for p in patches
|
|
if p[0] == d[0]]
|
|
patches += duplicates
|
|
|
|
return [(Snes(x[0]), x[1]) for x in patches]
|
|
|
|
#/* Guarantees at least s of each prize pack, over a total of n packs.
|
|
#* In each iteration, from the product n * m, use the guaranteed number
|
|
#* at k, where k is the "row" (integer division by m), when k falls
|
|
#* within the list boundary. Otherwise use the "column" (modulo by m)
|
|
#* as the random element.
|
|
#*/
|
|
def PrizePackRandomization(self, n: int, s: int):
|
|
m = 7
|
|
g = list(range(0, m)) * s
|
|
|
|
def randomization(n: int):
|
|
result = []
|
|
n = m * n
|
|
while (n > 0):
|
|
r = self.rnd.randrange(0, n)
|
|
k = r // m
|
|
result.append(g[k] if k < len(g) else r % m)
|
|
if (k < len(g)): del g[k]
|
|
n -= m
|
|
return result
|
|
|
|
return [(x + 1) for x in randomization(n)]
|
|
|
|
#/* Todo: Deadrock turns into $8F Blob when powdered, but those "onion blobs" always drop prize pack 1. */
|
|
def EnemyPrizePacks(self):
|
|
offset = 0xDB632
|
|
patches = [
|
|
#/* sprite_prep */
|
|
(0x6888D, [ 0x00 ]), #// Keese DW
|
|
(0x688A8, [ 0x00 ]), #// Rope
|
|
(0x68967, [ 0x00, 0x00 ]), #// Crow/Dacto
|
|
(0x69125, [ 0x00, 0x00 ]), #// Red/Blue Hardhat Bettle
|
|
#/* sprite properties */
|
|
(offset+0x01, [ 0x90 ]), #// Vulture
|
|
(offset+0x08, [ 0x00 ]), #// Octorok (One Way)
|
|
(offset+0x0A, [ 0x00 ]), #// Octorok (Four Way)
|
|
(offset+0x0D, [ 0x80, 0x90 ]), #// Buzzblob, Snapdragon
|
|
(offset+0x11, [ 0x90, 0x90, 0x00 ]), #// Hinox, Moblin, Mini Helmasaur
|
|
(offset+0x18, [ 0x90, 0x90 ]), #// Mini Moldorm, Poe/Hyu
|
|
(offset+0x20, [ 0x00 ]), #// Sluggula
|
|
(offset+0x22, [ 0x80, 0x00, 0x00 ]), #// Ropa, Red Bari, Blue Bari
|
|
#// Blue Soldier/Tarus, Green Soldier, Red Spear Soldier
|
|
#// Blue Assault Soldier, Red Assault Spear Soldier/Tarus
|
|
#// Blue Archer, Green Archer
|
|
#// Red Javelin Soldier, Red Bush Javelin Soldier
|
|
#// Red Bomb Soldiers, Green Soldier Recruits,
|
|
#// Geldman, Toppo
|
|
(offset+0x41, [ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x10, 0x90, 0x90, 0x80 ]),
|
|
(offset+0x4F, [ 0x80 ]), #// Popo 2
|
|
(offset+0x51, [ 0x80 ]), #// Armos
|
|
(offset+0x55, [ 0x00, 0x00 ]), #// Ku, Zora
|
|
(offset+0x58, [ 0x90 ]), #// Crab
|
|
(offset+0x64, [ 0x80 ]), #// Devalant (Shooter)
|
|
(offset+0x6A, [ 0x90, 0x90 ]), #// Ball N' Chain Trooper, Cannon Soldier
|
|
(offset+0x6D, [ 0x80, 0x80 ]), #// Rat/Buzz, (Stal)Rope
|
|
(offset+0x71, [ 0x80 ]), #// Leever
|
|
(offset+0x7C, [ 0x90 ]), #// Initially Floating Stal
|
|
(offset+0x81, [ 0xC0 ]), #// Hover
|
|
#// Green Eyegore/Mimic, Red Eyegore/Mimic
|
|
#// Detached Stalfos Body, Kodongo
|
|
(offset+0x83, [ 0x10, 0x10, 0x10, 0x00 ]),
|
|
(offset+0x8B, [ 0x10 ]), #// Gibdo
|
|
(offset+0x8E, [ 0x00, 0x00 ]), #// Terrorpin, Blob
|
|
(offset+0x91, [ 0x10 ]), #// Stalfos Knight
|
|
(offset+0x99, [ 0x10 ]), #// Pengator
|
|
(offset+0x9B, [ 0x10 ]), #// Wizzrobe
|
|
#// Blue Zazak, Red Zazak, Stalfos
|
|
#// Green Zirro, Blue Zirro, Pikit
|
|
(offset+0xA5, [ 0x10, 0x10, 0x10, 0x80, 0x80, 0x80 ]),
|
|
(offset+0xC7, [ 0x10 ]), #// Hokku-Bokku
|
|
(offset+0xC9, [ 0x10 ]), #// Tektite
|
|
(offset+0xD0, [ 0x10 ]), #// Lynel
|
|
(offset+0xD3, [ 0x00 ]), #// Stal
|
|
]
|
|
duplicates = [
|
|
#/* Popo2 -> Popo. Popo is not used in vanilla Z3, but we duplicate from Popo2 just to be sure */
|
|
(offset + 0x4F, offset + 0x4E),
|
|
]
|
|
return (patches, duplicates)
|
|
|
|
def WriteTexts(self, config: Config):
|
|
regions = [region for region in self.myWorld.Regions if isinstance(region, IReward)]
|
|
greenPendantDungeon = [region for region in regions if region.Reward == RewardType.PendantGreen][0]
|
|
redCrystalDungeons = [region for region in regions if region.Reward == RewardType.CrystalRed]
|
|
|
|
sahasrahla = Texts.SahasrahlaReveal(greenPendantDungeon)
|
|
self.stringTable.SetSahasrahlaRevealText(sahasrahla)
|
|
|
|
bombShop = Texts.BombShopReveal(redCrystalDungeons)
|
|
self.stringTable.SetBombShopRevealText(bombShop)
|
|
|
|
blind = Texts.Blind(self.rnd)
|
|
self.stringTable.SetBlindText(blind)
|
|
|
|
tavernMan = Texts.TavernMan(self.rnd)
|
|
self.stringTable.SetTavernManText(tavernMan)
|
|
|
|
ganon = Texts.GanonFirstPhase(self.rnd)
|
|
self.stringTable.SetGanonFirstPhaseText(ganon)
|
|
|
|
silversLocation = [loc for world in self.allWorlds for loc in world.Locations if loc.ItemIs(ItemType.SilverArrows, self.myWorld)]
|
|
if len(silversLocation) == 0:
|
|
silvers = Texts.GanonThirdPhaseMulti(None, self.myWorld, self.silversWorldID, self.playerIDToNames[self.silversWorldID])
|
|
else:
|
|
silvers = Texts.GanonThirdPhaseMulti(silversLocation[0].Region, self.myWorld) if config.Multiworld else \
|
|
Texts.GanonThirdPhaseSingle(silversLocation[0].Region)
|
|
self.stringTable.SetGanonThirdPhaseText(silvers)
|
|
|
|
triforceRoom = Texts.TriforceRoom(self.rnd)
|
|
self.stringTable.SetTriforceRoomText(triforceRoom)
|
|
|
|
def WriteStringTable(self):
|
|
#// Todo: v12, base table in asm, use move instructions in seed patch
|
|
self.patches.append((Snes(0x1C8000), self.stringTable.GetPaddedBytes()))
|
|
|
|
def WritePlayerNames(self):
|
|
self.patches += [(0x385000 + (0 * 16), self.PlayerNameBytes("Archipelago"))]
|
|
self.patches += [(0x385000 + (id * 16), self.PlayerNameBytes(name)) for name, id in self.playerNames.items() if id < 256]
|
|
|
|
def PlayerNameBytes(self, name: str):
|
|
name = (name[:16] if len(name) > 16 else name).center(16)
|
|
return bytearray(name, 'utf8')
|
|
|
|
def WriteSeedData(self):
|
|
configField1 = \
|
|
((1 if self.myWorld.Config.Race else 0) << 15) | \
|
|
((1 if self.myWorld.Config.Keysanity else 0) << 13) | \
|
|
((1 if self.myWorld.Config.Multiworld else 0) << 12) | \
|
|
(self.myWorld.Config.Z3Logic.value << 10) | \
|
|
(self.myWorld.Config.SMLogic.value << 8) | \
|
|
(Patch.Major << 4) | \
|
|
(Patch.Minor << 0)
|
|
|
|
configField2 = \
|
|
((1 if self.myWorld.Config.SwordLocation else 0) << 14) | \
|
|
((1 if self.myWorld.Config.MorphLocation else 0) << 12) | \
|
|
((1 if self.myWorld.Config.Goal else 0) << 8)
|
|
|
|
self.patches.append((Snes(0x80FF50), getWordArray(self.myWorld.Id)))
|
|
self.patches.append((Snes(0x80FF52), getWordArray(configField1)))
|
|
self.patches.append((Snes(0x80FF54), getDoubleWordArray(self.seed)))
|
|
self.patches.append((Snes(0x80FF58), getWordArray(configField2)))
|
|
#/* Reserve the rest of the space for future use */
|
|
self.patches.append((Snes(0x80FF5A), [0x00] * 6))
|
|
self.patches.append((Snes(0x80FF60), bytearray(self.seedGuid, 'utf8')))
|
|
self.patches.append((Snes(0x80FF80), bytearray(self.myWorld.Guid, 'utf8')))
|
|
|
|
def WriteCommonFlags(self):
|
|
#/* Common Combo Configuration flags at [asm]/config.asm */
|
|
if (self.myWorld.Config.Multiworld):
|
|
self.patches.append((Snes(0xF47000), getWordArray(0x0001)))
|
|
if (self.myWorld.Config.Keysanity):
|
|
self.patches.append((Snes(0xF47006), getWordArray(0x0001)))
|
|
|
|
def WriteGameTitle(self):
|
|
z3Glitch = "N" if self.myWorld.Config.Z3Logic == Config.Z3Logic.Nmg else \
|
|
"O" if self.myWorld.Config.Z3Logic == Config.Z3Logic.Owg else \
|
|
"C"
|
|
smGlitch = "N" if self.myWorld.Config.SMLogic == Config.SMLogic.Normal else \
|
|
"H" if self.myWorld.Config.SMLogic == Config.SMLogic.Hard else \
|
|
"X"
|
|
|
|
from Utils import __version__
|
|
self.title = f"ZSM{Patch.Major}{Patch.Minor}{Patch.Patch}{__version__.replace('.', '')[0:3]}{z3Glitch}{smGlitch}{self.myWorld.Id}{self.seed:08x}".ljust(21)[:21]
|
|
self.patches.append((Snes(0x00FFC0), bytearray(self.title, 'utf8')))
|
|
self.patches.append((Snes(0x80FFC0), bytearray(self.title, 'utf8')))
|
|
|
|
def WriteZ3KeysanityFlags(self):
|
|
if (self.myWorld.Config.Keysanity):
|
|
self.patches.append((Snes(0x40003B), [ 1 ])) #// MapMode #$00 = Always On (default) - #$01 = Require Map Item
|
|
self.patches.append((Snes(0x400045), [ 0x0f ])) #// display ----dcba a: Small Keys, b: Big Key, c: Map, d: Compass
|
|
self.patches.append((Snes(0x40016A), [ 0x01 ])) #// FreeItemText: db #$01 ; #00 = Off (default) - #$01 = On
|
|
|
|
def WriteSMKeyCardDoors(self):
|
|
plaquePlm = 0xd410
|
|
plmTablePos = 0xf800
|
|
|
|
if ( self.myWorld.Config.Keysanity):
|
|
doorList = [
|
|
#// RoomId Door Facing yyxx Keycard Event Type Plaque type yyxx, Address (if 0 a dynamic PLM is created)
|
|
#// Crateria
|
|
[ 0x91F8, KeycardDoors.Right, 0x2601, KeycardEvents.CrateriaLevel1, KeycardPlaque.Level1, 0x2400, 0x0000 ], #// Crateria - Landing Site - Door to gauntlet
|
|
[ 0x91F8, KeycardDoors.Left, 0x168E, KeycardEvents.CrateriaLevel1, KeycardPlaque.Level1, 0x148F, 0x801E ], #// Crateria - Landing Site - Door to landing site PB
|
|
[ 0x948C, KeycardDoors.Left, 0x062E, KeycardEvents.CrateriaLevel2, KeycardPlaque.Level2, 0x042F, 0x8222 ], #// Crateria - Before Moat - Door to moat (overwrite PB door)
|
|
[ 0x99BD, KeycardDoors.Left, 0x660E, KeycardEvents.CrateriaBoss, KeycardPlaque.Boss, 0x640F, 0x8470 ], #// Crateria - Before G4 - Door to G4
|
|
[ 0x9879, KeycardDoors.Left, 0x062E, KeycardEvents.CrateriaBoss, KeycardPlaque.Boss, 0x042F, 0x8420 ], #// Crateria - Before BT - Door to Bomb Torizo
|
|
|
|
#// Brinstar
|
|
[ 0x9F11, KeycardDoors.Left, 0x060E, KeycardEvents.BrinstarLevel1, KeycardPlaque.Level1, 0x040F, 0x8784 ], #// Brinstar - Blue Brinstar - Door to ceiling e-tank room
|
|
|
|
[ 0x9AD9, KeycardDoors.Right, 0xA601, KeycardEvents.BrinstarLevel2, KeycardPlaque.Level2, 0xA400, 0x0000 ], #// Brinstar - Green Brinstar - Door to etecoon area
|
|
[ 0x9D9C, KeycardDoors.Down, 0x0336, KeycardEvents.BrinstarBoss, KeycardPlaque.Boss, 0x0234, 0x863A ], #// Brinstar - Pink Brinstar - Door to spore spawn
|
|
[ 0xA130, KeycardDoors.Left, 0x161E, KeycardEvents.BrinstarLevel2, KeycardPlaque.Level2, 0x141F, 0x881C ], #// Brinstar - Pink Brinstar - Door to wave gate e-tank
|
|
[ 0xA0A4, KeycardDoors.Left, 0x062E, KeycardEvents.BrinstarLevel2, KeycardPlaque.Level2, 0x042F, 0x0000 ], #// Brinstar - Pink Brinstar - Door to spore spawn super
|
|
|
|
[ 0xA56B, KeycardDoors.Left, 0x161E, KeycardEvents.BrinstarBoss, KeycardPlaque.Boss, 0x141F, 0x8A1A ], #// Brinstar - Before Kraid - Door to Kraid
|
|
|
|
#// Upper Norfair
|
|
[ 0xA7DE, KeycardDoors.Right, 0x3601, KeycardEvents.NorfairLevel1, KeycardPlaque.Level1, 0x3400, 0x8B00 ], #// Norfair - Business Centre - Door towards Ice
|
|
[ 0xA923, KeycardDoors.Right, 0x0601, KeycardEvents.NorfairLevel1, KeycardPlaque.Level1, 0x0400, 0x0000 ], #// Norfair - Pre-Crocomire - Door towards Ice
|
|
|
|
[ 0xA788, KeycardDoors.Left, 0x162E, KeycardEvents.NorfairLevel2, KeycardPlaque.Level2, 0x142F, 0x8AEA ], #// Norfair - Lava Missile Room - Door towards Bubble Mountain
|
|
[ 0xAF72, KeycardDoors.Left, 0x061E, KeycardEvents.NorfairLevel2, KeycardPlaque.Level2, 0x041F, 0x0000 ], #// Norfair - After frog speedway - Door to Bubble Mountain
|
|
[ 0xAEDF, KeycardDoors.Down, 0x0206, KeycardEvents.NorfairLevel2, KeycardPlaque.Level2, 0x0204, 0x0000 ], #// Norfair - Below bubble mountain - Door to Bubble Mountain
|
|
[ 0xAD5E, KeycardDoors.Right, 0x0601, KeycardEvents.NorfairLevel2, KeycardPlaque.Level2, 0x0400, 0x0000 ], #// Norfair - LN Escape - Door to Bubble Mountain
|
|
|
|
[ 0xA923, KeycardDoors.Up, 0x2DC6, KeycardEvents.NorfairBoss, KeycardPlaque.Boss, 0x2EC4, 0x8B96 ], #// Norfair - Pre-Crocomire - Door to Crocomire
|
|
|
|
#// Lower Norfair
|
|
[ 0xB4AD, KeycardDoors.Left, 0x160E, KeycardEvents.LowerNorfairLevel1, KeycardPlaque.Level1, 0x140F, 0x0000 ], #// Lower Norfair - WRITG - Door to Amphitheatre
|
|
[ 0xAD5E, KeycardDoors.Left, 0x065E, KeycardEvents.LowerNorfairLevel1, KeycardPlaque.Level1, 0x045F, 0x0000 ], #// Lower Norfair - Exit - Door to "Reverse LN Entry"
|
|
[ 0xB37A, KeycardDoors.Right, 0x0601, KeycardEvents.LowerNorfairBoss, KeycardPlaque.Boss, 0x0400, 0x8EA6 ], #// Lower Norfair - Pre-Ridley - Door to Ridley
|
|
|
|
#// Maridia
|
|
[ 0xD0B9, KeycardDoors.Left, 0x065E, KeycardEvents.MaridiaLevel1, KeycardPlaque.Level1, 0x045F, 0x0000 ], #// Maridia - Mt. Everest - Door to Pink Maridia
|
|
[ 0xD5A7, KeycardDoors.Right, 0x1601, KeycardEvents.MaridiaLevel1, KeycardPlaque.Level1, 0x1400, 0x0000 ], #// Maridia - Aqueduct - Door towards Beach
|
|
|
|
[ 0xD617, KeycardDoors.Left, 0x063E, KeycardEvents.MaridiaLevel2, KeycardPlaque.Level2, 0x043F, 0x0000 ], #// Maridia - Pre-Botwoon - Door to Botwoon
|
|
[ 0xD913, KeycardDoors.Right, 0x2601, KeycardEvents.MaridiaLevel2, KeycardPlaque.Level2, 0x2400, 0x0000 ], #// Maridia - Pre-Colloseum - Door to post-botwoon
|
|
|
|
[ 0xD78F, KeycardDoors.Right, 0x2601, KeycardEvents.MaridiaBoss, KeycardPlaque.Boss, 0x2400, 0xC73B ], #// Maridia - Precious Room - Door to Draygon
|
|
|
|
[ 0xDA2B, KeycardDoors.BossLeft, 0x164E, 0x00f0, KeycardPlaque.Null, 0x144F, 0x0000 ], #// Maridia - Change Cac Alley Door to Boss Door (prevents key breaking)
|
|
|
|
#// Wrecked Ship
|
|
[ 0x93FE, KeycardDoors.Left, 0x167E, KeycardEvents.WreckedShipLevel1, KeycardPlaque.Level1, 0x147F, 0x0000 ], #// Wrecked Ship - Outside Wrecked Ship West - Door to Reserve Tank Check
|
|
[ 0x968F, KeycardDoors.Left, 0x060E, KeycardEvents.WreckedShipLevel1, KeycardPlaque.Level1, 0x040F, 0x0000 ], #// Wrecked Ship - Outside Wrecked Ship West - Door to Bowling Alley
|
|
[ 0xCE40, KeycardDoors.Left, 0x060E, KeycardEvents.WreckedShipLevel1, KeycardPlaque.Level1, 0x040F, 0x0000 ], #// Wrecked Ship - Gravity Suit - Door to Bowling Alley
|
|
|
|
[ 0xCC6F, KeycardDoors.Left, 0x064E, KeycardEvents.WreckedShipBoss, KeycardPlaque.Boss, 0x044F, 0xC29D ], #// Wrecked Ship - Pre-Phantoon - Door to Phantoon
|
|
]
|
|
|
|
doorId = 0x0000
|
|
for door in doorList:
|
|
#/* When "Fast Ganon" is set, don't place the G4 Boss key door to enable faster games */
|
|
if (door[0] == 0x99BD and self.myWorld.Config.Goal == Goal.FastGanonDefeatMotherBrain):
|
|
continue
|
|
doorArgs = doorId | door[3] if door[4] != KeycardPlaque.Null else door[3]
|
|
if (door[6] == 0):
|
|
#// Write dynamic door
|
|
doorData = []
|
|
for x in door[0:3]:
|
|
doorData += getWordArray(x)
|
|
doorData += getWordArray(doorArgs)
|
|
self.patches.append((Snes(0x8f0000 + plmTablePos), doorData))
|
|
plmTablePos += 0x08
|
|
else:
|
|
#// Overwrite existing door
|
|
doorData = []
|
|
for x in door[1:3]:
|
|
doorData += getWordArray(x)
|
|
doorData += getWordArray(doorArgs)
|
|
self.patches.append((Snes(0x8f0000 + door[6]), doorData))
|
|
if((door[3] == KeycardEvents.BrinstarBoss and door[0] != 0x9D9C) or door[3] == KeycardEvents.LowerNorfairBoss or door[3] == KeycardEvents.MaridiaBoss or door[3] == KeycardEvents.WreckedShipBoss):
|
|
#// Overwrite the extra parts of the Gadora with a PLM that just deletes itself
|
|
self.patches.append((Snes(0x8f0000 + door[6] + 0x06), [ 0x2F, 0xB6, 0x00, 0x00, 0x00, 0x00, 0x2F, 0xB6, 0x00, 0x00, 0x00, 0x00 ]))
|
|
|
|
#// Plaque data
|
|
if (door[4] != KeycardPlaque.Null):
|
|
plaqueData = getWordArray(door[0]) + getWordArray(plaquePlm) + getWordArray(door[5]) + getWordArray(door[4])
|
|
self.patches.append((Snes(0x8f0000 + plmTablePos), plaqueData))
|
|
plmTablePos += 0x08
|
|
doorId += 1
|
|
|
|
#/* Write plaque showing SM bosses that needs to be killed */
|
|
if (self.myWorld.Config.OpenTourian != OpenTourian.FourBosses):
|
|
plaqueData = getWordArray(0xA5ED) + getWordArray(plaquePlm) + getWordArray(0x044F) + getWordArray(KeycardPlaque.Zero + self.myWorld.TourianBossTokens)
|
|
self.patches.append((Snes(0x8f0000 + plmTablePos), plaqueData))
|
|
plmTablePos += 0x08
|
|
|
|
self.patches.append((Snes(0x8f0000 + plmTablePos), [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]))
|
|
|
|
def WriteDiggingGameRng(self):
|
|
digs = (self.rnd.randrange(30) + 1)
|
|
self.patches.append((Snes(0x308020), [ digs ]))
|
|
self.patches.append((Snes(0x1DFD95), [ digs ]))
|
|
|
|
#// Removes Sword/Shield from Uncle by moving the tiles for
|
|
#// sword/shield to his head and replaces them with his head.
|
|
def WriteRemoveEquipmentFromUncle(self, item: Item):
|
|
if (item.Type != ItemType.ProgressiveSword):
|
|
self.patches += [
|
|
(Snes(0xDD263), [ 0x00, 0x00, 0xF6, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD26B), [ 0x00, 0x00, 0xF6, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD293), [ 0x00, 0x00, 0xF6, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD29B), [ 0x00, 0x00, 0xF7, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD2B3), [ 0x00, 0x00, 0xF6, 0xFF, 0x02, 0x0E ]),
|
|
(Snes(0xDD2BB), [ 0x00, 0x00, 0xF6, 0xFF, 0x02, 0x0E ]),
|
|
(Snes(0xDD2E3), [ 0x00, 0x00, 0xF7, 0xFF, 0x02, 0x0E ]),
|
|
(Snes(0xDD2EB), [ 0x00, 0x00, 0xF7, 0xFF, 0x02, 0x0E ]),
|
|
(Snes(0xDD31B), [ 0x00, 0x00, 0xE4, 0xFF, 0x08, 0x0E ]),
|
|
(Snes(0xDD323), [ 0x00, 0x00, 0xE4, 0xFF, 0x08, 0x0E ]),
|
|
]
|
|
if (item.Type != ItemType.ProgressiveShield):
|
|
self.patches += [
|
|
(Snes(0xDD253), [ 0x00, 0x00, 0xF6, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD25B), [ 0x00, 0x00, 0xF6, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD283), [ 0x00, 0x00, 0xF6, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD28B), [ 0x00, 0x00, 0xF7, 0xFF, 0x00, 0x0E ]),
|
|
(Snes(0xDD2CB), [ 0x00, 0x00, 0xF6, 0xFF, 0x02, 0x0E ]),
|
|
(Snes(0xDD2FB), [ 0x00, 0x00, 0xF7, 0xFF, 0x02, 0x0E ]),
|
|
(Snes(0xDD313), [ 0x00, 0x00, 0xE4, 0xFF, 0x08, 0x0E ]),
|
|
]
|
|
|
|
def WritePreOpenPyramid(self, goal: Goal):
|
|
if (goal == Goal.FastGanonDefeatMotherBrain):
|
|
self.patches.append((Snes(0x30808B), [0x01]))
|
|
|
|
def WriteGanonInvicible(self, goal: Goal):
|
|
#/* Defaults to $00 (never) at [asm]/z3/randomizer/tables.asm */
|
|
valueMap = {
|
|
Goal.DefeatBoth : 0x03,
|
|
Goal.FastGanonDefeatMotherBrain : 0x04,
|
|
Goal.AllDungeonsDefeatMotherBrain : 0x02
|
|
}
|
|
value = valueMap.get(goal, None)
|
|
if (value is None):
|
|
raise exception(f"Unknown Ganon invincible value {goal}")
|
|
else:
|
|
self.patches.append((Snes(0x30803E), [value]))
|
|
|
|
def WriteBossesNeeded(self, tourianBossTokens):
|
|
self.patches.append((Snes(0xF47200), getWordArray(tourianBossTokens)))
|
|
|
|
def WriteCrystalsNeeded(self, towerCrystals, ganonCrystals, goal: Goal):
|
|
self.patches.append((Snes(0x30805E), [towerCrystals]))
|
|
self.patches.append((Snes(0x30805F), [ganonCrystals]))
|
|
|
|
self.stringTable.SetTowerRequirementText(f"You need {towerCrystals} crystals to enter Ganon's Tower.")
|
|
if (goal == Goal.AllDungeonsDefeatMotherBrain):
|
|
self.stringTable.SetGanonRequirementText(f"You need to complete all the dungeons and bosses to defeat Ganon.")
|
|
else:
|
|
self.stringTable.SetGanonRequirementText(f"You need {ganonCrystals} crystals to defeat Ganon.")
|
|
|
|
def WriteRngBlock(self):
|
|
#/* Repoint RNG Block */
|
|
self.patches.append((0x420000, [self.rnd.randrange(0, 0x100) for x in range(0, 1024)]))
|
|
|
|
def WriteSaveAndQuitFromBossRoom(self):
|
|
#/* Defaults to $00 at [asm]/z3/randomizer/tables.asm */
|
|
self.patches.append((Snes(0x308042), [ 0x01 ]))
|
|
|
|
def WriteWorldOnAgahnimDeath(self):
|
|
pass
|
|
#/* Defaults to $01 at [asm]/z3/randomizer/tables.asm */
|
|
#// Todo: Z3r major glitches disables this, reconsider extending or dropping with glitched logic later.
|
|
#//patches.Add((Snes(0x3080A3), new byte[] { 0x01 }));
|
|
|
|
def Snes(addr: int):
|
|
#/* Redirect hi bank $30 access into ExHiRom lo bank $40 */
|
|
if (addr & 0xFF8000) == 0x308000:
|
|
addr = 0x400000 | (addr & 0x7FFF)
|
|
else: #/* General case, add ExHi offset for banks < $80, and collapse mirroring */
|
|
addr = (0x400000 if addr < 0x800000 else 0)| (addr & 0x3FFFFF)
|
|
if (addr > 0x600000):
|
|
raise Exception(f"Unmapped pc address target ${addr:x}")
|
|
return addr
|
|
|
|
def getWord(w):
|
|
return (w & 0x00FF, (w & 0xFF00) >> 8)
|
|
|
|
def getWordArray(w):
|
|
return [w & 0x00FF, (w & 0xFF00) >> 8]
|
|
|
|
def getDoubleWordArray(w):
|
|
return [w & 0x000000FF, (w & 0x0000FF00) >> 8, (w & 0x00FF0000) >> 16, (w & 0xFF000000) >> 24]
|
|
|
|
"""
|
|
byte[] UintBytes(int value) => BitConverter.GetBytes((uint)value);
|
|
|
|
byte[] UshortBytes(int value) => BitConverter.GetBytes((ushort)value);
|
|
|
|
byte[] AsAscii(string text) => Encoding.ASCII.GetBytes(text);
|
|
|
|
}
|
|
|
|
}
|
|
"""
|
|
def SplitOff(source: List[Any], count: int):
|
|
head = source[:count]
|
|
tail = source[count:]
|
|
return (head, tail)
|