132911
"Death Stranding: Director's Cut - Steam v1.004"
1
103835
"Table Info & Credits"
1
103826
"Special Thanks to: TheyCallMeTim13, kraqurjak, & G40sty from OCT & kraqurjak's discord"
1
130343
"Special Thanks to: JC from CTG/GuidedHacking for the help & videos"
1
130511
"Join CTG's Discord"
Auto Assembler Script
{$lua}
[ENABLE]
shellExecute('https://discordapp.com/invite/ndn4pqs')
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
107730
"Special Thanks to: mgr.inz.Player For His Compact Mode Script"
1
133241
"Credits to machine4578 for updating roads script on v1.001"
1
133462
"Credits to Anon9 for their (FRF) DS v1.6 table"
1
133463
"Credits to Fling (https://flingtrainer.com/) for their v1.6 trainer"
1
133482
"Credits to Sunbeam for updating the Anon9 v1.06 scripts "enemies don't attack" & "ignore hits" from DS 1.06 > DSDC 1.001"
Auto Assembler Script
{$lua}
[ENABLE]
shellExecute('https://fearlessrevolution.com/viewtopic.php?f=4&t=19689&start=15')
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
105367
"Download Updates Here"
Auto Assembler Script
{$lua}
[ENABLE]
shellExecute('https://opencheattables.com/viewtopic.php?t=555')
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
130235
"Toggle Compact Mode"
Auto Assembler Script
[ENABLE]
// Script Creaded By mgr.inz.Player On CE Forums
LuaCall(function cycleFullCompact(sender,force) local state = not(compactmenuitem.Caption == 'Compact View Mode'); if force~=nil then state = not force end; compactmenuitem.Caption = state and 'Compact View Mode' or 'Full View Mode'; getMainForm().Splitter1.Visible = state; getMainForm().Panel4.Visible = state; getMainForm().Panel5.Visible = state; end; function addCompactMenu() if compactmenualreadyexists then return end; local parent = getMainForm().Menu.Items; compactmenuitem = createMenuItem(parent); parent.add(compactmenuitem); compactmenuitem.Caption = 'Compact View Mode'; compactmenuitem.OnClick = cycleFullCompact; compactmenualreadyexists = 'yes'; end; addCompactMenu(); cycleFullCompact(nil,true))
[DISABLE]
LuaCall(cycleFullCompact(nil,false))
132796
"Reminders/Goals:"
1
132834
"remove blood from player suit"
1
132800
"find a way to spawn items"
1
132912
"-----------------------------"
1
133628
"Load Table"
Auto Assembler Script
[ENABLE]
aobscanmodule(PlayerX,$process,C5 F8 11 87 80 00 00 00 C4 41) // should be unique
registersymbol(PlayerX)
aobscanmodule(VehicleX,$process,C5 FB 10 87 C8 00 00 00 * * * * 30) // should be unique
registersymbol(VehicleX)
aobscanmodule(WaypointX,$process,EA C5 F8 10 70 10) // should be unique
registersymbol(WaypointX)
aobscanmodule(CarrierX,$process,4C 24 20 C5 F8 10 80 C8 00 00 00) // should be unique
registersymbol(CarrierX)
aobscanmodule(PlayerBaseStatsAOB,$process,C5 FA 10 83 C0 00 00 00 * 89) // should be unique
registersymbol(PlayerBaseStatsAOB)
aobscanmodule(BBStressAOB,$process,3C 43 00 00 C4 C1 7A 10 86 34 43 00 00) // should be unique
registersymbol(BBStressAOB)
aobscanmodule(PlayerBatteryAOB,$process,C5 FA 10 81 10 48 00 00 33) // should be unique
registersymbol(PlayerBatteryAOB)
aobscanmodule(CurrentAMMOAOB,$process,0F B7 18 E8 5D DC F1 FF) // should be unique
registersymbol(CurrentAMMOAOB)
aobscanmodule(BloodBagAOB,$process,41 8B 85 38 48 00 00) // should be unique
registersymbol(BloodBagAOB)
aobscanmodule(CurrentWeightAOB,$process,8B 41 0C 89 87 C4 00 00 00) // should be unique
registersymbol(CurrentWeightAOB)
aobscanmodule(MaxWeightAOB,$process,C4 C1 7A 10 97 58 0C 00 00) // should be unique
registersymbol(MaxWeightAOB)
aobscanmodule(UrinationAOB,$process,C4 C1 4A 5F 86 4C 48 00 00) // should be unique
registersymbol(UrinationAOB)
aobscanmodule(CryptobioteInBackpackAOB,$process,44 8B 00 41 8B CE 49 8B C6) // should be unique
registersymbol(CryptobioteInBackpackAOB)
aobscanmodule(PlayerSuitAOB,$process,C5 FA 10 81 58 03 00 00) // should be unique
registersymbol(PlayerSuitAOB)
aobscanmodule(BridgesEnergyAOB,$process,C5 FA 10 57 04 76) // should be unique
registersymbol(BridgesEnergyAOB)
aobscanmodule(ChiralCrystalsInBackpackAOB,$process,41 8B 84 C9 08 24 00 00) // should be unique
registersymbol(ChiralCrystalsInBackpackAOB)
aobscanmodule(FacilityChiralCrystalsAOB,$process,48 8B 44 1A 30) // should be unique
registersymbol(FacilityChiralCrystalsAOB)
aobscanmodule(VehicleBatteryAOB,$process,C5 78 2F 78 08 72 0A) // should be unique
registersymbol(VehicleBatteryAOB)
aobscanmodule(VehicleDurabilityAOB,$process,C5 FA 10 B1 E8 06 00 00) // should be unique
registersymbol(VehicleDurabilityAOB)
aobscanmodule(VehiclePhysicalConditionAOB,$process,C5 FA 10 BF 84 00 00 00) // should be unique
registersymbol(VehiclePhysicalConditionAOB)
aobscanmodule(DamageAOB,$process,C5 FA 10 4A 34 * * * * 0F) // should be unique
registersymbol(DamageAOB)
aobscanmodule(ContainerDamageAOB,$process,C5 FA 10 42 30 C4 C1) // should be unique
registersymbol(ContainerDamageAOB)
aobscanmodule(CurrentTimeStandardOrdersAOB,$process,C5 FB 11 43 38 * * * * 24) // should be unique
registersymbol(CurrentTimeStandardOrdersAOB)
aobscanmodule(MaxTimeStandardOrdersAOB,$process,C4 C1 7A 10 60 14) // should be unique
registersymbol(MaxTimeStandardOrdersAOB)
aobscanmodule(LikesAOB,$process,49 03 49 18 48 8B 90 80 14 00 00) // should be unique
registersymbol(LikesAOB)
//aobscanmodule(MULEsNonLethalHealthAOB,$process,8B 81 F0 01 00 00 89) // should be unique
//registersymbol(MULEsNonLethalHealthAOB)
aobscanmodule(MULEsNonLethalHealthAOB2,$process,C5 FA 10 03 C4 C1 7A 5C 4E 04) // should be unique ds.exe+2B2669A
registersymbol(MULEsNonLethalHealthAOB2)
aobscanmodule(MULEsLethalHealthAOB,$process,C5 FA 10 8B EC 01 00 00 * 32) // should be unique
registersymbol(MULEsLethalHealthAOB)
aobscanmodule(MULEsLethalHealthAOB2,$process,C5 FA 10 8E EC 01 00 00 C4) // should be unique ds.exe+2B266C8
registersymbol(MULEsLethalHealthAOB2)
aobscanmodule(MachineGunAOB,$process,C5 FA 10 48 50 * 8B) // should be unique
registersymbol(MachineGunAOB)
aobscanmodule(MachineGunCurrentAOB,$process,20 C5 FA 58 49 50) // should be unique
registersymbol(MachineGunCurrentAOB)
aobscanmodule(EnemyAmmoAOB,$process,0F B7 18 33 C0) // should be unique
registersymbol(EnemyAmmoAOB)
aobscanmodule(BT_OneHitKillAOB,$process,C5 FA 10 83 3C 01 00 00 * * * * 0F B6) // should be unique
registersymbol(BT_OneHitKillAOB)
aobscanmodule(Order64_OneHitKillBTAOB,$process,C5 FA 10 86 30 01 00 00 * * * * 34) // should be unique
registersymbol(Order64_OneHitKillBTAOB)
aobscanmodule(Order65BossHealthPhase1AOB,$process,C5 78 2F 93 58 01 00 00 0F 93) // should be unique
registersymbol(Order65BossHealthPhase1AOB)
aobscanmodule(Order65_PlayerHealth_PunchOutAOB,$process,C5 FA 10 80 DC 00 00 00 * * * * 7A) // should be unique
registersymbol(Order65_PlayerHealth_PunchOutAOB)
aobscanmodule(Order65_PlayerStamina_PunchOutAOB,$process,C5 FA 10 54 37 38) // should be unique
registersymbol(Order65_PlayerStamina_PunchOutAOB)
aobscanmodule(Order65Punchout_HiggsHealthAOB,$process,C4 C1 7A 10 96 58 01 00 00) // should be unique
registersymbol(Order65Punchout_HiggsHealthAOB)
aobscanmodule(Order65Punchout_HiggsHealthOHKAOB,$process,C5 FA 10 80 58 01 00 00 75) // should be unique
registersymbol(Order65Punchout_HiggsHealthOHKAOB)
aobscanmodule(AutoPaverMaterialsAOB,$process,44 8B 89 10 02 00 00) // should be unique
registersymbol(AutoPaverMaterialsAOB)
aobscanmodule(EquipmentUseAOB,$process,44 0F BF 09 0F B6 C0) // should be unique
registersymbol(EquipmentUseAOB)
//newopcode ds.exe+2F32BE0
aobscanmodule(StructuresDurabilityAOB,$process,C5 FA 10 B8 D8 00 00 00) // should be unique
registersymbol(StructuresDurabilityAOB)
aobscanmodule(CurrentStructureDurabilityAOB,$process,C5 FA 10 88 D8 00 00 00 * * * * 1C) // should be unique
registersymbol(CurrentStructureDurabilityAOB)
aobscanmodule(MaxRoadDurabilityAOB,$process,C5 FA 10 40 0C * * * * 05) // should be unique
registersymbol(MaxRoadDurabilityAOB)
aobscanmodule(StructureBuildTimerAOB,$process,1C C5 FA 10 8F D8 00 00 00) // should be unique
registersymbol(StructureBuildTimerAOB)
aobscanmodule(BTsRemoveOilAOB,$process,C5 78 2F 86 3C 01 00 00 * * * * A3) // should be unique
registersymbol(BTsRemoveOilAOB)
//ds.exe+2C563BF
aobscanmodule(AllSmallCargoAOB,$process,0F B6 4B 3E 83 E9 01 74 3B) // should be unique
registersymbol(AllSmallCargoAOB)
aobscanmodule(ItemIDAOB,$process,48 8B 49 28 48 89 55 2F) // should be unique
registersymbol(ItemIDAOB)
aobscanmodule(SlotIDAOB,$process,48 8B 46 28 45 33 E4) // should be unique
registersymbol(SlotIDAOB)
aobscanmodule(DrillTrainingTimerAOB,$process,0D * * * * C5 FB 10 81 18 01 00 00) // should be unique
registersymbol(DrillTrainingTimerAOB)
aobscanmodule(RaceTrackTotalTimeAOB,$process,C5 FB 10 88 B0 02 00 00 * * * * E8) // should be unique
registersymbol(RaceTrackTotalTimeAOB)
aobscanmodule(SandalweedAOB,$process,8B 84 2F 0C 38 00 00) // should be unique
registersymbol(SandalweedAOB)
aobscanmodule(DrillTargetsAOB,$process,8B 43 2C 44 8B 43 24) // should be unique
registersymbol(DrillTargetsAOB)
aobscanmodule(RaceTrack_CurrentLapAOB,$process,0F B7 88 D4 00 00 00) // should be unique
registersymbol(RaceTrack_CurrentLapAOB)
//ds.exe+28AEAD0
aobscanmodule(DontTripAOB,$process,77 1A 80 B9 51 09 00 00 00) // should be unique
registersymbol(DontTripAOB)
//$process+343B7EC
aobscanmodule(MaxMaterialStorageAOB,$process,42 8B 44 81 68) // should be unique
registersymbol(MaxMaterialStorageAOB)
aobscanmodule(PCCStructureFacilityMaterialsAOB,$process,44 8B 89 7C 02 00 00) // should be unique
registersymbol(PCCStructureFacilityMaterialsAOB)
aobscanmodule(PCCMaxMaterialStorageAOB,$process,48 63 48 08 48 89 4C 24 30) // should be unique
registersymbol(PCCMaxMaterialStorageAOB)
aobscanmodule(NoRecoilAOB,$process,C5 FA 11 A1 F4 04 00 00) // should be unique
registersymbol(NoRecoilAOB)
//ds.exe+294106A
aobscanmodule(RapidFireAOB,$process,C5 7A 11 87 9C 04 00 00 C4) // should be unique
registersymbol(RapidFireAOB)
//ds.exe+2FEFD45
aobscanmodule(CliffUngerHealthAOB,$process,C5 FA 10 86 60 01 00 00 * * * * 20) // should be unique
registersymbol(CliffUngerHealthAOB)
//$process+271BCD1 for ignorehits
aobscanmodule(IgnoreHitsAOB,$process,84 C0 0F 84 51 04 00 00 8B 47) // should be unique
registersymbol(IgnoreHitsAOB)
{ working, but not compatible with csimbi table
//ds.exe+29382CD for Max Magazine Ammo
aobscanmodule(MaxMagazineAmmoAOB,$process,3B 50 58 44 0F 43 70 58) // should be unique
registersymbol(MaxMagazineAmmoAOB)
}
//ds.exe+294121B for Max Magazine Ammo
aobscanmodule(MaxMagazineAmmoAOB,$process,83 78 58 00 77 0F) // should be unique
registersymbol(MaxMagazineAmmoAOB)
//ds.exe+2CAE4F2 for MaxAmmo
aobscanmodule(MaxAmmoAOB,$process,66 44 89 04 41 C3) // should be unique
registersymbol(MaxAmmoAOB)
alloc(newmem,$1000,PlayerX)
alloc(CurrentTimeStandardOrdersXMM, 4)
// Store Address Symbols
label(PlayerCoordinates VehicleCoordinates WaypointCoordinates CarrierCoordinates RoadDurability PlayerStats CurrentAmmo BBStress PlayerBattery BloodBag CurrentWeight MaxWeight Urination Cryptobiote PlayerSuit BridgesEnergy ChiralCrystalsInBackpack FacilityChiralCrystals VehicleBattery VehicleDurability VehiclePhysicalCondition Damage ContainerDamage CurrentTimeStandardOrders MaxTimeStandardOrders Likes MULEsNonLethalHealth2 MULEsLethalHealth MULEsLethalHealth2 MachineGun MachineGunPlayer EnemyAmmo BTHealth Order64_BossHP Order65BossHealthPhase1 Order65_PlayerHealth_PunchOut Order65_PlayerStamina_PunchOut Order65Punchout_HiggsHealth AutoPaverMaterials EquipmentUse CurrentStructureDurability StructureBuildTimer ItemID SlotID DrillTrainingTimer RaceTrackTotalTime Sandalweed DrillTargets RaceTrack_CurrentLap PCCStructureFacilityMaterials CliffUngerHealth WeaponDelaySpeed MaxAmmo MaxMagazineAmmo)
registersymbol(PlayerCoordinates VehicleCoordinates WaypointCoordinates CarrierCoordinates RoadDurability PlayerStats CurrentAmmo BBStress PlayerBattery BloodBag CurrentWeight MaxWeight Urination Cryptobiote PlayerSuit BridgesEnergy ChiralCrystalsInBackpack FacilityChiralCrystals VehicleBattery VehicleDurability VehiclePhysicalCondition Damage ContainerDamage CurrentTimeStandardOrders MaxTimeStandardOrders Likes MULEsNonLethalHealth2 MULEsLethalHealth MULEsLethalHealth2 MachineGun MachineGunPlayer EnemyAmmo BTHealth Order64_BossHP Order65BossHealthPhase1 Order65_PlayerHealth_PunchOut Order65_PlayerStamina_PunchOut Order65Punchout_HiggsHealth AutoPaverMaterials EquipmentUse CurrentStructureDurability StructureBuildTimer ItemID SlotID DrillTrainingTimer RaceTrackTotalTime Sandalweed DrillTargets RaceTrack_CurrentLap PCCStructureFacilityMaterials CliffUngerHealth WeaponDelaySpeed MaxAmmo MaxMagazineAmmo)
// Flag Symbols
label(flag_InfPlayerHealth flag_InfConsciousness flag_InfStamina flag_NoFatigue flag_FullFatigue flag_InfEndurance flag_MaxBootsDurability flag_NoBBStress flag_InfPlayerBattery flag_InfAmmo flag_InfBloodBag flag_0CurrentWeight flag_InfMaxWeight flag_MaxUrination flag_NoUrination flag_MaxCryptobiote flag_MaxDCryptobiote flag_CleanPlayerSuit flag_OptionalBackpackCoverClean flag_InfBridgesEnergy flag_MaxChiralCrystalsInBackpack flag_InfFacilityChiralCrystals flag_InfVehicleBattery flag_InfiniteVehicleDurability flag_InfVehiclePhysicalCondition flag_MULEsVehicleBattery0 flag_Damage0 flag_ContainerDamage0 flag_CurrentTimeStandardOrders0 flag_MaxTimeStandardOrders100Min flag_MULEsNonLethalHealth0 flag_MULEsNonLethalHealth1000 flag_MULEsLethalHealth0 flag_MULEsLethalHealth1000 flag_MachineGunDead flag_MachineGunMax Flag_EnemyAmmo0 flag_OneHitKillBT flag_Order64_OneHitKillBT flag_Order65Phase1OneHitKill flag_Order65_InfPlayerHealth_PunchOut flag_Order65_PlayerMaxStamina_PunchOut flag_Order65Punchout_Higgs1HitKill flag_AutoPaverMaterials8000 flag_InfEquipmentUse flag_RepairAllStructures flag_0StructureBuildTime flag_BTOilNoHP flag_BTOilHPGainBack flag_AllSmallCargo flag_InfDrillTrainingTimer flag_10MinDrillTrainingTimer flag_RaceTrackTotalTime0 flag_RaceTrackLapTime0 flag_Sandalweed999 flag_InfEquipment2 flag_RaceTrackInstantWin flag_DontTrip flag_MaxMaterialStorage flag_PCCStructureFacilityMaterials99999 flag_PCCMaxMaterialStorage99999 flag_NoRecoil flag_RapidFire flag_CliffUngerHealth0 flag_IgnoreHits flag_BulletSpeed flag_NoBloodorChiralSpent flag_RateOfFire)
registersymbol(flag_InfPlayerHealth flag_InfConsciousness flag_InfStamina flag_NoFatigue flag_FullFatigue flag_InfEndurance flag_MaxBootsDurability flag_NoBBStress flag_InfPlayerBattery flag_InfAmmo flag_InfBloodBag flag_0CurrentWeight flag_InfMaxWeight flag_MaxUrination flag_NoUrination flag_MaxCryptobiote flag_MaxDCryptobiote flag_CleanPlayerSuit flag_OptionalBackpackCoverClean flag_InfBridgesEnergy flag_MaxChiralCrystalsInBackpack flag_InfFacilityChiralCrystals flag_InfVehicleBattery flag_InfiniteVehicleDurability flag_InfVehiclePhysicalCondition flag_MULEsVehicleBattery0 flag_Damage0 flag_ContainerDamage0 flag_CurrentTimeStandardOrders0 flag_MaxTimeStandardOrders100Min flag_MULEsNonLethalHealth0 flag_MULEsNonLethalHealth1000 flag_MULEsLethalHealth0 flag_MULEsLethalHealth1000 flag_MachineGunDead flag_MachineGunMax Flag_EnemyAmmo0 flag_OneHitKillBT flag_Order64_OneHitKillBT flag_Order65Phase1OneHitKill flag_Order65_InfPlayerHealth_PunchOut flag_Order65_PlayerMaxStamina_PunchOut flag_Order65Punchout_Higgs1HitKill flag_AutoPaverMaterials8000 flag_InfEquipmentUse flag_RepairAllStructures flag_0StructureBuildTime flag_BTOilNoHP flag_BTOilHPGainBack flag_AllSmallCargo flag_InfDrillTrainingTimer flag_10MinDrillTrainingTimer flag_RaceTrackTotalTime0 flag_RaceTrackLapTime0 flag_Sandalweed999 flag_InfEquipment2 flag_RaceTrackInstantWin flag_DontTrip flag_MaxMaterialStorage flag_PCCStructureFacilityMaterials99999 flag_PCCMaxMaterialStorage99999 flag_NoRecoil flag_RapidFire flag_CliffUngerHealth0 flag_IgnoreHits flag_BulletSpeed flag_NoBloodorChiralSpent flag_RateOfFire)
CurrentTimeStandardOrdersXMM:
dq (double)0
newmem:
{------------------------------------------------------------------------------}
//Get X Coordinate for Player
PlayerXInjection:
LoadPlayerXAddresses:
mov [PlayerCoordinates], rdi
OriginalPlayerXCode:
vmovups [rdi+00000080],xmm0
ExitPlayerXInjection:
jmp ReturnFromPlayerXInjection
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get X Coordinate for Vehicle
VehicleXInjection:
LoadVehicleXAddresses:
cmp word ptr [rdi+20C],#1542
jne OriginalVehicleXCode
mov [VehicleCoordinates],rdi
OriginalVehicleXCode:
vmovsd xmm0,[rdi+000000C8]
ExitVehicleXInjection:
jmp ReturnFromVehicleXInjection
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get X Coordinate for Waypoint (Last Created)
WaypointXInjection:
LoadWaypointXAddresses:
mov [WaypointCoordinates],rax
OriginalWaypointXCode:
vmovups xmm6,[rax+10]
ExitWaypointXInjection:
jmp ReturnFromWaypointXInjection
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get X Coordinate for Carrier (Last Attached)
CarrierXInjection:
LoadCarrierXAddresses:
//cmp dword ptr [rax+488],1
//jne OriginalCarrierXCode
mov [CarrierCoordinates], rax
OriginalCarrierXCode:
vmovups xmm0,[rax+000000C8]
ExitCarrierXInjection:
jmp ReturnFromCarrierXInjection
db 90 90 90 90
{------------------------------------------------------------------------------}
//Player Health/Stats
EnterPlayerStatsInjection:
GetPlayerStatsBase:
mov [PlayerStats], rbx
CheckInfPlayerHealthFlag:
cmp [flag_InfPlayerHealth],1
jne CheckInfConsciousnessFlag
InfPlayerHealth:
//mov [rbx+000000C0],(float)1000
push rcx
mov ecx,[rbx+C4]
mov [rbx+C0],ecx
pop rcx
CheckInfConsciousnessFlag:
cmp [flag_InfConsciousness],1
jne CheckInfStaminaFlag
InfConsciousness:
mov [rbx+000000DC],(float)1000
CheckInfStaminaFlag:
cmp [flag_InfStamina],1
jne CheckNoFatigueFlag
InfStamina:
mov [rbx+00000110],(float)1000
CheckNoFatigueFlag:
cmp [flag_NoFatigue],1
jne CheckFullFatigueFlag
NoFatigue:
mov [rbx+00000130],(float)0
CheckFullFatigueFlag:
cmp [flag_FullFatigue],1
jne CheckInfEnduranceFlag
FullFatigue:
mov [rbx+00000130],(float)10000
CheckInfEnduranceFlag:
cmp [flag_InfEndurance],1
jne CheckMaxBootsDurabilityFlag
InfEndurance:
mov [rbx+00000140],(float)1000
CheckMaxBootsDurabilityFlag:
cmp [flag_MaxBootsDurability],1
jne OriginalPlayerStatsCode
MaxBootsDurability:
//mov [rbx+0000032C],(float)1700
push rcx
mov ecx,[rbx+330]
mov [rbx+32C],ecx
pop rcx
OriginalPlayerStatsCode:
vmovss xmm0,[rbx+000000C0]
ExitPlayerStatsInjection:
jmp ReturnFromPlayerStatsInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//BB Stress Level
EnterBBStressLevelInjection:
GetBBStressBase:
mov [BBStress],r14 // load base address to symbol
CheckBBStressLevelFlag:
cmp [flag_NoBBStress],1
jne OriginalBBStressLevelCode
NoBBStress:
mov [r14+00004334],(float)0
OriginalBBStressLevelCode:
vmovss xmm0,[r14+00004334]
ExitBBStressLevelInjection:
jmp ReturnFromBBStressLevelInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Player Battery
EnterPlayerBatteryInjection:
GetPlayerBatteryBase:
mov [PlayerBattery], rcx
CheckInfPlayerBatteryFlag:
cmp [flag_InfPlayerBattery],1
jne OriginalPlayerBatteryCode
InfPlayerBattery:
mov [rcx+00004810],(float)1000
OriginalPlayerBatteryCode:
vmovss xmm0,[rcx+00004810]
ExitPlayerBatteryInjection:
jmp ReturnFromPlayerBatteryInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Current Ammo
EnterCurrentAmmoInjection:
GetCurrentAmmoBase:
mov [CurrentAmmo], rax
CheckInfAmmoFlag:
cmp [flag_InfAmmo],1
jne OriginalCurrentAmmoCode
InfAmmo:
mov [rax],#30
OriginalCurrentAmmoCode:
movzx ebx,word ptr [rax]
//call $process+27A43C0
ExitCurrentAmmoCountInjection:
jmp ReturnFromCurrentAmmoInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Blood Bag
EnterBloodBagInjection:
GetBloodBagBase:
mov [BloodBag],r13
CheckInfBloodBagFlag:
cmp [flag_InfBloodBag],1
jne OriginalBloodBagCode
InfBloodBag:
//mov [r13+00004838],(float)1000
push rcx
mov ecx,[r13+483C]
mov [r13+4838],ecx
pop rcx
OriginalBloodBagCode:
mov eax,[r13+00004838]
ExitBloodBagInjection:
jmp ReturnFromBloodBagInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Current Weight
EnterCurrentWeightInjection:
GetCurrentWeightBase:
mov [CurrentWeight], rcx
Check0CurrentWeightFlag:
cmp [flag_0CurrentWeight],1
jne OriginalCurrentWeightCode
0CurrentWeight:
mov [rcx+0C],(float)0
OriginalCurrentWeightCode:
mov eax,[rcx+0C]
mov [rdi+000000C4],eax
ExitCurrentWeightInjection:
jmp ReturnFromCurrentWeightInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Max Weight
EnterMaxWeightInjection:
GetMaxWeightBase:
mov [MaxWeight], r15
CheckInfMaxWeightFlag:
cmp [flag_InfMaxWeight],1
jne OriginalMaxWeightCode
InfMaxWeight:
mov [r15+00000C58],(float)5000
OriginalMaxWeightCode:
vmovss xmm2,[r15+00000C58]
ExitMaxWeightInjection:
jmp ReturnFromMaxWeightInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Urination
EnterUrinationInjection:
GetUrinationBase:
mov [Urination], r14
CheckMaxUrinationFlag:
cmp [flag_MaxUrination],1
jne CheckNoUrinationFlag
MaxUrination:
mov [r14+0000484C],(float)1000
CheckNoUrinationFlag:
cmp [flag_NoUrination],1
jne OriginalUrinationCode
NoUrination:
mov [r14+0000484C],(float)0
OriginalUrinationCode:
vmaxss xmm0,xmm6,[r14+0000484C]
ExitUrinationInjection:
jmp ReturnFromUrinationInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Cryptobiote
EnterCryptobioteInjection:
GetCryptobioteBase:
mov [Cryptobiote], rax
CheckMaxCryptobioteFlag:
cmp [flag_MaxCryptobiote],1
jne CheckMaxDCryptobioteFlag
MaxCryptobiote:
mov [rax],(int)999
CheckMaxDCryptobioteFlag:
cmp [flag_MaxDCryptobiote],1
jne OriginalCryptobioteCode
MaxDCryptobiote:
mov [rax+48],(int)999
OriginalCryptobioteCode:
mov r8d,[rax]
mov ecx,r14d
ExitCryptobioteInjection:
jmp ReturnFromCryptobioteInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Player Suit Condition
EnterPlayerSuitInjection:
GetPlayerSuitBase:
mov [PlayerSuit], rcx
CheckCleanPlayerSuitFlag:
cmp [flag_CleanPlayerSuit],1
jne CheckOptionalBackpackCoverCleanFlag
CleanPlayerSuit:
mov [rcx+00000358],(float)5000
CheckOptionalBackpackCoverCleanFlag:
cmp [flag_OptionalBackpackCoverClean],1
jne OriginalPlayerSuitCode
OptionalBackpackCoverClean:
mov [rcx+000047A8],(float)4500
OriginalPlayerSuitCode:
vmovss xmm0,[rcx+00000358]
ExitPlayerSuitInjection:
jmp ReturnFromPlayerSuitInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Bridges Energy (formerly Monster Drink)
EnterBridgesEnergyInjection:
GetBridgesEnergyBase:
mov [BridgesEnergy], rdi
CheckInfBridgesEnergykFlag:
cmp [flag_InfBridgesEnergy],1
jne OriginalBridgesEnergyCode
InfBridgesEnergy:
mov [rdi+04],(float)1000
OriginalBridgesEnergyCode:
vmovss xmm2,[rdi+04]
ExitBridgesEnergyInjection:
jmp ReturnFromBridgesEnergyInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Chiral Crystals In Backpack
EnterChiralCrystalsInBackpackInjection:
GetChiralCrystalsInBackpackBase:
push rbx
lea rbx,[r9+rcx*8+00002408]
mov [ChiralCrystalsInBackpack],rbx
pop rbx
CheckMaxChiralCrystalsInBackpackFlag:
cmp [flag_MaxChiralCrystalsInBackpack],1
jne OriginalChiralCrystalsInBackpackCode
MaxChiralCrystalsInBackpack:
mov [r9+rcx*8+00002408],(int)99999
OriginalChiralCrystalsInBackpackCode:
mov eax,[r9+rcx*8+00002408]
ExitChiralCrystalsInBackpackInjection:
jmp ReturnFromChiralCrystalsInBackpackInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Facility Materials
EnterFacilityChiralCrystalsInjection:
GetFacilityChiralCrystalsBase:
push rcx
lea rcx,[rdx+rbx+30]
mov [FacilityChiralCrystals],rcx
pop rcx
CheckInfFacilityChiralCrystalsFlag:
cmp [flag_InfFacilityChiralCrystals],1
jne OriginalFacilityChiralCrystalsCode
InfFacilityChiralCrystals:
mov rax,(int)99999
mov [rdx+rbx+30],rax
jmp ReturnFromFacilityChiralCrystalsInject
//push rcx
//lea rcx,[rdx+rbx+30]
//mov [rcx],(int)99999
//mov [rcx+08],(int)99999
//mov [rcx+10],(int)99999
//mov [rcx+18],(int)99999
//mov [rcx+28],(int)99999
//pop rcx
OriginalFacilityChiralCrystalsCode:
mov rax,[rdx+rbx+30]
ExitFacilityChiralCrystalsInjection:
jmp ReturnFromFacilityChiralCrystalsInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Vehicle Battery
EnterVehicleBatteryInjection:
GetVehicleBatteryBase:
mov [VehicleBattery],rax // load base address to symbol
CheckInfVehicleBatteryFlag:
cmp [flag_InfVehicleBattery],1
jne OriginalVehicleBatteryCode
InfVehicleBattery:
//mov [rax+08],(float)9000
push rcx
mov ecx,[rax+0C]
mov [rax+08],ecx
pop rcx
OriginalVehicleBatteryCode:
vcomiss xmm15,[rax+08]
ExitVehicleBatteryInjection:
jmp ReturnFromVehicleBatteryInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Vehicle Durability
EnterVehicleDurabilityInjection:
GetVehicleDurabilityBase:
mov [VehicleDurability],rcx // load base address to symbol
CheckInfiniteVehicleDurabilityFlag:
cmp [flag_InfiniteVehicleDurability],1
jne OriginalVehicleDurabilityCode
InfiniteVehicleDurability:
//mov [rcx+000006E8],(float)15000
push rax
mov eax,[rcx+6EC]
mov [rcx+6E8],eax
pop rax
OriginalVehicleDurabilityCode:
vmovss xmm6,[rcx+000006E8]
ExitVehicleDurabilityInjection:
jmp ReturnFromVehicleDurabilityInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Vehicle Physical Conition (Rust Removal)
EnterVehiclePhysicalConditionInjection:
GetVehiclePhysicalConditionBase:
cmp dword ptr [rbx+240],5
jne OriginalVehiclePhysicalConditionCode
mov [VehiclePhysicalCondition],rdi // load base address to symbol
CheckInfVehiclePhysicalConditionFlag:
cmp [flag_InfVehiclePhysicalCondition],1
jne OriginalVehiclePhysicalConditionCode
InfVehiclePhysicalCondition:
//remove the cmp/jne to clean all vehicles the address finds
cmp dword ptr [rbx+240],5
jne OriginalVehiclePhysicalConditionCode
mov [rdi+00000084],(float)1
OriginalVehiclePhysicalConditionCode:
vmovss xmm7,[rdi+00000084]
ExitVehiclePhysicalConditionInjection:
jmp ReturnFromVehiclePhysicalConditionInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Damage % on Equipment
EnterDamageInjection:
GetDamageBase:
mov [Damage],rdx // load base address to symbol
CheckDamage0Flag:
cmp [flag_Damage0],1
jne OriginalDamage0Code
Damage0:
mov [rdx+34],(float)30000
OriginalDamage0Code:
vmovss xmm1,[rdx+34]
ExitDamage0Injection:
jmp ReturnFromDamage0Inject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Container Damage on Equipment
EnterContainerDamageInjection:
GetContainerDamageBase:
mov [ContainerDamage],rdx // load base address to symbol
CheckContainerDamage0Flag:
cmp [flag_ContainerDamage0],1
jne OriginalContainerDamage0Code
ContainerDamage0:
mov [rdx+30],(float)1000
OriginalContainerDamage0Code:
vmovss xmm0,[rdx+30]
ExitContainerDamage0Injection:
jmp ReturnFromContainerDamage0Inject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Current Time on Standard Orders
EnterCurrentTimeStandardOrdersInjection:
GetCurrentTimeStandardOrdersBase:
mov [CurrentTimeStandardOrders],rbx
CheckCurrentTimeStandardOrders0Flag:
cmp [flag_CurrentTimeStandardOrders0],1
jne OriginalCurrentTimeStandardOrdersCode
CurrentTimeStandardOrders0:
vmovsd xmm0,[CurrentTimeStandardOrdersXMM]
OriginalCurrentTimeStandardOrdersCode:
vmovsd [rbx+38],xmm0
ExitCurrentTimeStandardOrdersInjection:
jmp ReturnCurrentTimeStandardOrdersInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Max Time on Standard Orders
EnterMaxTimeStandardOrdersInjection:
GetMaxTimeStandardOrdersBase:
mov [MaxTimeStandardOrders],r8
CheckMaxTimeStandardOrders100MinFlag:
cmp [flag_MaxTimeStandardOrders100Min],1
jne OriginalMaxTimeStandardOrdersCode
MaxTimeStandardOrders100Min:
mov [r8+14],(float)5999.990234
OriginalMaxTimeStandardOrdersCode:
vmovss xmm4,[r8+14]
ExitMaxTimeStandardOrdersInjection:
jmp ReturnMaxTimeStandardOrdersInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Likes
EnterLikesInjection:
GetLikesBase:
mov [Likes],r9
OriginalLikesCode:
add rcx,[r9+18]
mov rdx,[rax+00001480]
ExitLikesInjection:
jmp ReturnFromLikesInjection
db 90 90 90 90
{------------------------------------------------------------------------------}
{
//One Hit Kill for Mules / Respawn (Non-Lethal Weapons)
//Always writes, using MULEsNonLethalHealthAOB2 to get specific Current Health pointer
EnterMULEsNonLethalHealthInjection:
//GetMULEsNonLethalHealthBase:
//mov [MULEsNonLethalHealth],rcx
CheckMULEsNonLethalHealth0Flag:
cmp [flag_MULEsNonLethalHealth0],1
jne CheckMULEsNonLethalHealth1000Flag
MULEsNonLethalHealth0:
mov [rcx+000001F0],(float)0
CheckMULEsNonLethalHealth1000Flag:
cmp [flag_MULEsNonLethalHealth1000],1
jne OriginalMULEsNonLethalHealthCode
MULEsNonLethalHealth1000:
mov [rcx+000001F0],(float)1000
OriginalMULEsNonLethalHealthCode:
mov eax,[rcx+000001F0]
ExitMULEsNonLethalHealthInjection:
jmp ReturnFromMULEsNonLethalHealthInject
db 90 90 90 90
}
{------------------------------------------------------------------------------}
////Get Pointer for Current Health of Mule (Non-Lethal)
EnterMULEsNonLethalHealth2Injection:
GetMULEsNonLethalHealth2Base:
mov [MULEsNonLethalHealth2],rbx
CheckMULEsNonLethalHealth0Flag:
cmp [flag_MULEsNonLethalHealth0],1
jne CheckMULEsNonLethalHealth1000Flag
MULEsNonLethalHealth0:
mov [rbx],(float)0
CheckMULEsNonLethalHealth1000Flag:
cmp [flag_MULEsNonLethalHealth1000],1
jne OriginalMULEsNonLethalHealth2Code
MULEsNonLethalHealth1000:
mov [rbx],(float)1000
OriginalMULEsNonLethalHealth2Code:
vmovss xmm0,[rbx]
vsubss xmm1,xmm0,[r14+04]
ExitMULEsNonLethalHealth2Injection:
jmp ReturnFromMULEsNonLethalHealth2Inject
db 90 90 90 90
{------------------------------------------------------------------------------}
//One Hit Kill MULEs (Lethal Weapons)
EnterMULEsLethalHealthInjection:
GetMULEsLethalHealthBase:
mov [MULEsLethalHealth],rbx
{
CheckMULEsLethalHealth0Flag:
cmp [flag_MULEsLethalHealth0],1
jne CheckMULEsLethalHealth1000Flag
MULEsLethalHealth0:
mov [rbx+000001EC],(float)0
CheckMULEsLethalHealth1000Flag:
cmp [flag_MULEsLethalHealth1000],1
jne OriginalMULEsLethalHealthCode
MULEsLethalHealth1000:
mov [rbx+000001EC],(float)1000
}
OriginalMULEsLethalHealthCode:
vmovss xmm1,[rbx+000001EC]
ExitMULEsLethalHealthInjection:
jmp ReturnMULEsLethalHealthInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get Pointer for Current Health of Mule (Lethal) & One Hit Kill
EnterMULEsLethalHealth2Injection:
GetMULEsLethalHealth2Base:
mov [MULEsLethalHealth2],rsi
CheckMULEsLethalHealth0Flag:
cmp [flag_MULEsLethalHealth0],1
jne CheckMULEsLethalHealth1000Flag
MULEsLethalHealth0:
mov [rsi+000001EC],(float)0
CheckMULEsLethalHealth1000Flag:
cmp [flag_MULEsLethalHealth1000],1
jne OriginalMULEsLethalHealth2Code
MULEsLethalHealth1000:
mov [rsi+000001EC],(float)1000
OriginalMULEsLethalHealth2Code:
vmovss xmm1,[rsi+000001EC]
ExitMULEsLethalHealth2Injection:
jmp ReturnMULEsLethalHealth2Inject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Machine Gun (All)
EnterMachineGunInjection:
GetMachineGunBase:
mov [MachineGun],rax
CheckMachineGun0Flag:
cmp [flag_MachineGunDead],1
jne OriginalMachineGunCode
MachineGunDead:
mov [rax+50],(float)101
OriginalMachineGunCode:
vmovss xmm1,[rax+50]
ExitMachineGunInjection:
jmp ReturnFromMachineGunInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Machine Gun (Last Used by Player)
EnterMachineGunPlayerInjection:
GetMachineGunPlayerBase:
mov [MachineGunPlayer],rcx
CheckMachineGunMaxFlag:
cmp [flag_MachineGunMax],1
jne OriginalMachineGunPlayerCode
MachineGunMax:
mov [rcx+50],(float)0
OriginalMachineGunPlayerCode:
vaddss xmm1,xmm0,[rcx+50]
ExitMachineGunPlayerInjection:
jmp ReturnFromMachineGunPlayerInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Enemy Ammo, set to 0
EnterEnemyAmmoInjection:
GetEnemyAmmoBase:
mov [EnemyAmmo],rax
CheckFlag_EnemyAmmo0Flag:
cmp [Flag_EnemyAmmo0],1
jne OriginalEnemyAmmoCode
EnemyAmmo0:
mov [rax],#0
OriginalEnemyAmmoCode:
movzx ebx,word ptr [rax]
xor eax,eax
ExitEnemyAmmoInjection:
jmp ReturnFromEnemyAmmoInject
db 90 90 90 90
{------------------------------------------------------------------------------}
// Kill all BT's in one hit except Order 64 BT boss
EnterBTKillInjection:
GetBTHealthBase:
mov [BTHealth],rbx
CheckOneHitKillBTFlag:
cmp [flag_OneHitKillBT],1
jne OriginalBTHealthCode
OneHitKillBT:
mov [rbx+0000013C],(float)0
OriginalBTHealthCode:
vmovss xmm0,[rbx+0000013C]
ExitBTKillInjection:
jmp ReturnBTHealthInjection
db 90 90 90 90
{------------------------------------------------------------------------------}
//Kill Order 64 BT Boss in one hit
EnterOrder64BTKillInjection:
GetOrder64_BossHPBase:
mov [Order64_BossHP],rsi
CheckOrder64_OneHitKillBTFlag:
cmp [flag_Order64_OneHitKillBT],1
jne OriginalOrder64BTKillCode
Order64_OneHitKillBT:
mov [rsi+00000130],(float)0
OriginalOrder64BTKillCode:
vmovss xmm0,[rsi+00000130]
ExitOrder64BTKillInjection:
jmp ReturnFromOrder64_OneHitKillBTInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get the Address for Enemy Health On Order 65 Phase 1 (Shootout & Hand to Hand)
EnterOrder65BossHealthPhase1Injection:
GetOrder65BossHealthPhase1Base:
mov [Order65BossHealthPhase1], rbx
CheckOrder65Phase1OneHitKillFlag:
cmp [flag_Order65Phase1OneHitKill],1
jne OriginalOrder65BossHealthPhase1Code
Order65Phase1OneHitKill:
mov [rbx+00000158],(float)0
OriginalOrder65BossHealthPhase1Code:
vcomiss xmm10,[rbx+00000158]
ExitOriginalOrder65BossHealthPhase1CodeInjection:
jmp ReturnFromOrder65BossHealthPhase1CodeInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get the Address for Player Health On Order 65 PunchOut
EnterOrder65_PlayerHealth_PunchOutInjection:
GetOrder65_PlayerHealth_PunchOutBase:
mov [Order65_PlayerHealth_PunchOut], rax
CheckOrder65_InfPlayerHealth_PunchOutFlag:
cmp [flag_Order65_InfPlayerHealth_PunchOut],1
jne OriginalOrder65_PlayerHealth_PunchOutCode
Order65_InfPlayerHealth_PunchOut:
mov [rax+000000DC],(float)1000
OriginalOrder65_PlayerHealth_PunchOutCode:
vmovss xmm0,[rax+000000DC]
ExitOrder65_PlayerHealth_PunchOutInjection:
jmp ReturnFromOrder65_PlayerHealth_PunchOutInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get the Address for Player Stamina On Order 65 PunchOut
EnterOrder65_PlayerStamina_PunchOutInjection:
GetOrder65_PlayerStamina_PunchOutBase:
push rax
lea rax,[rdi+rsi+38]
mov [Order65_PlayerStamina_PunchOut], rax
pop rax
CheckOrder65_PlayerMaxStamina_PunchOutFlag:
cmp [flag_Order65_PlayerMaxStamina_PunchOut],1
jne OriginalOrder65_PlayerStamina_PunchOutCode
Order65_PlayerMaxStamina_PunchOut:
mov [rdi+rsi+38],(float)1
OriginalOrder65_PlayerStamina_PunchOutCode:
vmovss xmm2,[rdi+rsi+38]
ExitOrder65_PlayerStamina_PunchOutInjection:
jmp ReturnFromOrder65_PlayerStamina_PunchOutInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Get Higgs Order 65 Higgs [Punchout] health
EnterOrder65Punchout_HiggsHealthInjection:
GetOrder65Punchout_HiggsHealthBase:
mov [Order65Punchout_HiggsHealth],r14
{
CheckOrder65Punchout_Higgs1HitKillFlag:
cmp [flag_Order65Punchout_Higgs1HitKill],1
jne OriginalOrder65Punchout_HiggsHealthCode
Order65Punchout_Higgs1HitKill:
mov [r14+00000158],(float)0
}
OriginalOrder65Punchout_HiggsHealthCode:
vmovss xmm2,[r14+00000158]
ExitOrder65Punchout_HiggsHealthInjection:
jmp ReturnFromOrder65Punchout_HiggsHealthInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Kill Order 65 Higgs [Punchout] in one combination of attacks
EnterOrder65Punchout_HiggsHealthOHKInjection:
CheckOrder65Punchout_Higgs1HitKillFlag:
cmp [flag_Order65Punchout_Higgs1HitKill],1
jne OriginalOrder65Punchout_HiggsHealthOHKCode
Order65Punchout_Higgs1HitKill:
mov [rax+00000158],(float)200
OriginalOrder65Punchout_HiggsHealthOHKCode:
vmovss xmm0,[rax+00000158]
jmp ReturnFromOrder65Punchout_HiggsHealthOHKInject
ExitOrder65Punchout_HiggsHealthOHKInjection:
jmp ReturnFromOrder65Punchout_HiggsHealthOHKInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Auto-Paver Materials Needed
EnterAutoPaverMaterialsInjection:
GetAutoPaverMaterialsBase:
mov [AutoPaverMaterials],rcx
CheckAutoPaverMaterials8000Flag:
cmp [flag_AutoPaverMaterials8000],1
jne OriginalAutoPaverMaterialsCode
AutoPaverMaterials8000:
mov [rcx+00000210],#15000 //Chiral Crystals
mov [rcx+00000214],#15000 //Resins
mov [rcx+00000218],#15000 //Metals
mov [rcx+0000021C],#15000 //Ceramics
mov [rcx+00000220],#15000 //Chemicals
mov [rcx+00000224],#15000 //Special Alloys
OriginalAutoPaverMaterialsCode:
mov r9d,[rcx+00000210]
ExitAutoPaverMaterials8000Injection:
jmp ReturnFromAutoPaverMaterials8000Inject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Equipment Use (Ladders, Container Spray, etc)
EnterEquipmentUseInjection:
GetEquipmentUseBase:
mov [EquipmentUse],rax
CheckInfEquipmentUseFlag:
cmp [flag_InfEquipmentUse],1
jne OriginalInfEquipmentUseCode
InfEquipmentUse:
mov [rcx],#10
OriginalInfEquipmentUseCode:
movsx r9d,word ptr [rcx]
movzx eax,al
ExitInfEquipmentUseInjection:
jmp ReturnFromInfEquipmentUseInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Repair All Personal Structures (Temporary, restarting game sets back to original)
EnterRepairAllStructuresInjection:
CheckRepairAllStructuresFlag:
cmp [flag_RepairAllStructures],1
jne OriginalRepairAllStructuresCode
RepairAllStructures:
mov [rax+000000D8],(float)900000
OriginalRepairAllStructuresCode:
vmovss xmm7,[rax+000000D8]
//vcomiss xmm0,[rcx+000000D8] old aob
ExitRepairAllStructuresInjection:
jmp ReturnFromRepairAllStructuresInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Current Structure Durability (Temporary, restarting game sets back to original)
EnterCurrentStructureDurabilityInjection:
GetCurrentStructureDurabilityBase:
mov [CurrentStructureDurability],rax
OriginalCurrentStructureDurabilityCode:
vmovss xmm1,[rax+000000D8]
ExitCurrentStructureDurabilityInjection:
jmp ReturnFromCurrentStructureDurabilityInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Repair All Roads
EnterRepairAllRoadsInjection:
GetRoadDurabilityBase:
mov [RoadDurability],rax
CheckRepairAllRoadsFlag:
cmp [flag_RepairAllRoads],1
jne OriginalRepairAllRoadsCode
RepairAllRoads:
mov [rax+0C],(float)100
OriginalRepairAllRoadsCode:
vmovss xmm0,[rax+0C]
ExitRepairAllRoadsInjection:
jmp ReturnFromRepairAllRoadsInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Structure Build Timer
EnterStructureBuildTimerInjection:
GetStructureBuildTimerBase:
mov [StructureBuildTimer],rdi
Check0StructureBuildTimeFlag:
cmp [flag_0StructureBuildTime],1
jne OriginalStructureBuildTimerCode
0StructureBuildTime:
mov [rdi+000000D8],(float)0
OriginalStructureBuildTimerCode:
vmovss xmm1,[rdi+000000D8]
jmp ReturnFromStructureBuildTimerInject
ExitStructureBuildTimerInjection:
jmp ReturnFromStructureBuildTimerInject
db 90 90 90 90
{------------------------------------------------------------------------------}
EnterBTOilInjection:
CheckBTOilNoHPlag:
cmp [flag_BTOilNoHP],1
jne CheckBTOilHPGainFlag
BTOilNoHP:
mov [rsi+0000013C],(float)0
CheckBTOilHPGainFlag:
cmp [flag_BTOilHPGainBack],1
jne OriginalBTOilCode
BTOilHPGainBack:
mov [rsi+0000013C],(float)100
OriginalBTOilCode:
vcomiss xmm8,[rsi+0000013C]
ExitBTOilInjection:
jmp ReturnFromBTOilInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Make All Cargo Small (Credits Anon-9 for original script)
EnterAllSmallCargoInjection:
CheckAllSmallCargoFlag:
cmp [flag_AllSmallCargo],1
jne OriginalAllSmallCargoCode
AllSmallCargo:
mov byte ptr [rbx+3E],0
OriginalAllSmallCargoCode:
movzx ecx,byte ptr [rbx+3E]
sub ecx,01
ExitAllSmallCargoInjection:
jmp ReturnFromAllSmallCargoInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Item ID (Max)
EnterItemIDInjection:
GetItemIDBase:
mov [ItemID],rcx
OriginalItemIDCode:
mov rcx,[rcx+28]
mov [rbp+2F],rdx
jmp ReturnFromItemIDInject
ExitItemIDInjection:
jmp ReturnFromItemIDInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Slot ID (Current)
EnterSlotIDInjection:
GetSlotIDBase:
mov [SlotID],rsi
OriginalSlotIDCode:
mov rax,[rsi+28]
xor r12d,r12d
jmp ReturnFromSlotIDInject
ExitSlotIDInjection:
jmp ReturnFromSlotIDInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Drill Training Timer
EnterDrillTrainingTimerInjection:
GetDrillTrainingTimerBase:
mov [DrillTrainingTimer],rcx
CheckInfDrillTrainingTimerFlag:
cmp [flag_InfDrillTrainingTimer],1
jne Check10MinDrillTrainingTimerFlag
InfDrillTrainingTimer:
mov [rcx+0000011C],(int)1085763612
Check10MinDrillTrainingTimerFlag:
cmp [flag_10MinDrillTrainingTimer],1
jne OriginalDrillTrainingTimerCode
10MinDrillTrainingTimer:
mov [rcx+0000011C],(int)1082310656
OriginalDrillTrainingTimerCode:
vmovsd xmm0,[rcx+00000118]
ExitDrillTrainingTimerInjection:
jmp ReturnFromDrillTrainingTimerInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Race Track Total Time & Lap Time
EnterRaceTrackTotalTimeInjection:
GetRaceTrackTotalTimeBase:
mov [RaceTrackTotalTime],rax
CheckRaceTrackTotalTime0Flag:
cmp [flag_RaceTrackTotalTime0],1
jne CheckRaceTrackLapTime0Flag
RaceTrackTotalTime0:
mov [rax+000002B4],(int)0
CheckRaceTrackLapTime0Flag:
cmp [flag_RaceTrackLapTime0],1
jne OriginalRaceTrackTotalTimeCode
RaceTrackLapTime0:
mov [rax+000002BC],(int)0.00
OriginalRaceTrackTotalTimeCode:
vmovsd xmm1,[rax+000002B0]
ExitRaceTrackTotalTimeInjection:
jmp ReturnFromRaceTrackTotalTimeInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Sandalweed
EnterSandalweedInjection:
GetSandalweedBase:
push rbx
lea rbx,[rdi+rbp+0000380C]
mov [Sandalweed], rbx
pop rbx
CheckSandalweed999Flag:
cmp [flag_Sandalweed999],1
jne OriginalSandalweedCode
Sandalweed999:
mov [rdi+rbp+0000380C],#999
OriginalSandalweedCode:
mov eax,[rdi+rbp+0000380C]
ExitSandalweedInjection:
jmp ReturnFromSandalweedInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Drill Targets (Visual Only)
EnterDrillTargetsInjection:
GetDrillTargetsBase:
mov [DrillTargets],rbx
OriginalDrillTargetsCode:
mov eax,[rbx+2C]
mov r8d,[rbx+24]
ExitDrillTargetsInjection:
jmp ReturnFromDrillTargetsInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Race Track Current Lap
EnterRaceTrack_CurrentLapInjection:
GetRaceTrack_CurrentLapBase:
mov [RaceTrack_CurrentLap],rax
CheckRaceTrackInstantWinFlag:
cmp [flag_RaceTrackInstantWin],1
jne OriginalRaceTrack_CurrentLapCode
RaceTrackInstantWin:
mov [rax+000000D4],(int)3
OriginalRaceTrack_CurrentLapCode:
movzx ecx,word ptr [rax+000000D4]
ExitRaceTrack_CurrentLapInjection:
jmp ReturnFromRaceTrack_CurrentLapInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Don't Trip
EnterDontTripInjection:
CheckDontTripFlag:
cmp [flag_DontTrip],1
jne OriginalDontTripCode
DontTrip:
jmp $process+28AEADF
cmp byte ptr [rcx+00000951],00
jmp ReturnFromDontTripInject
OriginalDontTripCode:
ja $process+28AEAEC
cmp byte ptr [rcx+00000951],00
jmp ReturnFromDontTripInject
ExitDontTripInjection:
jmp ReturnFromDontTripInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Max Material Storage (99999)
//$process+343B7EC
EnterMaxMaterialStorageInjection:
CheckMaxMaterialStorageFlag:
cmp [flag_MaxMaterialStorage],1
jne OriginalMaxMaterialStorageCode
MaxMaterialStorage:
mov eax,(int)99999
mov [rcx+r8*4+68],eax
jmp $process+343B7F1
OriginalMaxMaterialStorageCode:
mov eax,[rcx+r8*4+68]
jmp ReturnFromMaxMaterialStorageInject
ExitMaxMaterialStorageInjection:
jmp ReturnFromMaxMaterialStorageInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//PCC Structure Facility Materials
EnterPCCStructureFacilityMaterialsInjection:
GetPCCStructureFacilityMaterialsBase:
push rax
lea rax, [rcx+0000027C]
mov [PCCStructureFacilityMaterials],rax
pop rax
CheckPCCStructureFacilityMaterials99999Flag:
cmp [flag_PCCStructureFacilityMaterials99999],1
jne OriginalPCCStructureFacilityMaterialsCode
PCCStructureFacilityMaterials99999:
mov r9d,(int)99999
mov [rcx+0000027C],r9d
mov [rcx+00000280],r9d
mov [rcx+00000284],r9d
mov [rcx+00000288],r9d
mov [rcx+0000028C],r9d
mov [rcx+00000290],r9d
jmp ReturnFromPCCStructureFacilityMaterialsInject
//push rax
//lea rax, [rcx+0000027C]
//mov [rax],(int)99999
//mov [rax+04],(int)99999
//mov [rax+08],(int)99999
//mov [rax+C],(int)99999
//mov [rax+10],(int)99999
//mov [rax+14],(int)99999
//pop rax
OriginalPCCStructureFacilityMaterialsCode:
mov r9d,[rcx+0000027C]
jmp ReturnFromPCCStructureFacilityMaterialsInject
ExitPCCStructureFacilityMaterialsInjection:
jmp ReturnFromPCCStructureFacilityMaterialsInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Max PCC Material Storage (99999)
EnterPCCMaxMaterialStorageInjection:
CheckPCCMaxMaterialStorage99999Flag:
cmp [flag_PCCMaxMaterialStorage99999],1
jne OriginalPCCMaxMaterialStorageCode
PCCMaxMaterialStorage99999:
mov [rax],(int)99999
mov [rax+04],(int)99999
mov [rax+08],(int)99999
mov [rax+C],(int)99999
mov [rax+10],(int)99999
mov [rax+14],(int)99999
OriginalPCCMaxMaterialStorageCode:
movsxd rcx,dword ptr [rax+08]
mov [rsp+30],rcx
jmp ReturnFromPCCMaxMaterialStorageInject
ExitPCCMaxMaterialStorageInjection:
jmp ReturnFromPCCMaxMaterialStorageInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//No Recoil
EnterNoRecoilInjection:
CheckNoRecoilFlag:
cmp [flag_NoRecoil],1
jne OriginalNoRecoilCode
NoRecoil:
subss xmm7,xmm7
jmp ReturnFromNoRecoilInject
OriginalNoRecoilCode:
vmovss [rcx+000004F4],xmm4
ExitNoRecoilInjection:
jmp ReturnFromNoRecoilInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Rapid Fire
EnterRapidFireInjection:
GetRapidFireBase:
mov [WeaponDelaySpeed],rdi
CheckRapidFireFlag:
cmp [flag_RapidFire],1
jne OriginalRapidFireCode
RapidFire:
subss xmm8,xmm8
OriginalRapidFireCode:
vmovss [rdi+0000049C],xmm8
ExitRapidFireInjection:
jmp ReturnFromRapidFireInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Kill Cliff Unger In One Hit
EnterCliffUngerHealthInjection:
GetCliffUngerHealthBase:
mov [CliffUngerHealth],rsi
CheckCliffUngerHealth0Flag:
cmp [flag_CliffUngerHealth0],1
jne OriginalCliffUngerHealthCode
CliffUngerHealth0:
mov [rsi+00000160],(int)0
OriginalCliffUngerHealthCode:
vmovss xmm0,[rsi+00000160]
jmp ReturnFromCliffUngerHealthInject
ExitCliffUngerHealthInjection:
jmp ReturnFromCliffUngerHealthInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//Ignore Hits / Invulnerable
EnterIgnoreHitsInjection:
CheckIgnoreHitsFlag:
cmp [flag_IgnoreHits],1
jne OriginalIgnoreHitsCode
IgnoreHits:
xor al,al
OriginalIgnoreHitsCode:
test al,al
je short @f
jmp ReturnFromIgnoreHitsInject
@@:
jmp $process+271C12A
jmp ReturnFromIgnoreHitsInject
ExitIgnoreHitsInjection:
jmp ReturnFromIgnoreHitsInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//[Max] Max Magazine Ammo
EnterMaxMagazineAmmoInjection:
GetMaxMagazineAmmoBase:
mov [MaxMagazineAmmo],rax
CheckBulletSpeedFlag:
cmp [flag_BulletSpeed],1
jne CheckRateOfFireSpeedFlag
BulletSpeed:
mov [rax+68],(float)999
CheckRateOfFireSpeedFlag:
cmp [flag_RateOfFire],1
jne CheckNoBloodorChiralSpentFlag
RateOfFire:
mov [rax+78],(float)0
CheckNoBloodorChiralSpentFlag:
cmp [flag_NoBloodorChiralSpent],1
jne OriginalMaxMagazineAmmoCode
NoBloodorChiralSpent:
mov [rax+8C],(float)0
OriginalMaxMagazineAmmoCode:
cmp dword ptr [rax+58],00
ja $process+2941230
jmp ReturnFromMaxMagazineAmmoInject
ExitMaxMagazineAmmoInjection:
jmp ReturnFromMaxMagazineAmmoInject
db 90 90 90 90
{------------------------------------------------------------------------------}
//MaxAmmo
EnterMaxAmmoInjection:
GetMaxAmmoBase:
mov [MaxAmmo],rcx
OriginalMaxAmmoCode:
mov [rcx+rax*2],r8w
ExitMaxAmmoInjection:
jmp ReturnFromMaxAmmoInject
db 90 90 90 90
{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
// Address Data Declarations / Reserved Bytes
align 8,cc
PlayerCoordinates:
resb 8
VehicleCoordinates:
resb 8
WaypointCoordinates:
resb 8
CarrierCoordinates:
resb 8
PlayerStats:
resb 8
BBStress:
resb 8
PlayerBattery:
resb 8
CurrentAmmo:
resb 8
BloodBag:
resb 8
CurrentWeight:
resb 8
MaxWeight:
resb 8
Urination:
resb 8
Cryptobiote:
resb 8
PlayerSuit:
resb 8
BridgesEnergy:
resb 8
ChiralCrystalsInBackpack:
resb 8
FacilityChiralCrystals:
resb 8
VehicleBattery:
resb 8
VehicleDurability:
resb 8
VehiclePhysicalCondition:
resb 8
Damage:
resb 8
ContainerDamage:
resb 8
CurrentTimeStandardOrders:
resb 8
MaxTimeStandardOrders:
resb 8
Likes:
resb 8
MULEsNonLethalHealth2:
resb 8
MULEsLethalHealth:
resb 8
MULEsLethalHealth2:
resb 8
MachineGun:
resb 8
MachineGunPlayer:
resb 8
EnemyAmmo:
resb 8
BTHealth:
resb 8
Order64_BossHP:
resb 8
Order65BossHealthPhase1:
resb 8
Order65_PlayerHealth_PunchOut:
resb 8
Order65_PlayerStamina_PunchOut:
resb 8
Order65Punchout_HiggsHealth:
resb 8
AutoPaverMaterials:
resb 8
EquipmentUse:
resb 8
RoadDurability:
resb 8
CurrentStructureDurability:
resb 8
StructureBuildTimer:
resb 8
ItemID:
resb 8
SlotID:
resb 8
DrillTrainingTimer:
resb 8
RaceTrackTotalTime:
resb 8
Sandalweed:
resb 8
DrillTargets:
resb 8
RaceTrack_CurrentLap:
resb 8
PCCStructureFacilityMaterials:
resb 8
WeaponDelaySpeed:
resb 8
CliffUngerHealth:
resb 8
MaxMagazineAmmo:
resb 8
MaxAmmo:
resb 8
flag_InfPlayerHealth:
dd 0
dd 0
flag_InfConsciousness:
dd 0
dd 0
flag_InfStamina:
dd 0
dd 0
flag_NoFatigue:
dd 0
dd 0
flag_FullFatigue:
dd 0
dd 0
flag_InfEndurance:
dd 0
dd 0
flag_MaxBootsDurability:
dd 0
dd 0
flag_NoBBStress:
dd 0
dd 0
flag_InfPlayerBattery:
dd 0
dd 0
flag_InfAmmo:
dd 0
dd 0
flag_InfBloodBag:
dd 0
dd 0
flag_0CurrentWeight:
dd 0
dd 0
flag_InfMaxWeight:
dd 0
dd 0
flag_NoUrination:
dd 0
dd 0
flag_MaxUrination:
dd 0
dd 0
flag_MaxCryptobiote:
dd 0
dd 0
flag_MaxDCryptobiote:
dd 0
dd 0
flag_CleanPlayerSuit:
dd 0
dd 0
flag_OptionalBackpackCoverClean:
dd 0
dd 0
flag_InfBridgesEnergy:
dd 0
dd 0
flag_MaxChiralCrystalsInBackpack:
dd 0
dd 0
flag_InfFacilityChiralCrystals:
dd 0
dd 0
flag_InfVehicleBattery:
dd 0
dd 0
flag_MULEsVehicleBattery0:
dd 0
dd 0
flag_InfiniteVehicleDurability:
dd 0
dd 0
flag_InfVehiclePhysicalCondition:
dd 0
dd 0
flag_Damage0:
dd 0
dd 0
flag_ContainerDamage0:
dd 0
dd 0
flag_CurrentTimeStandardOrders0:
dd 0
dd 0
flag_MaxTimeStandardOrders100Min:
dd 0
dd 0
flag_MULEsNonLethalHealth0:
dd 0
dd 0
flag_MULEsNonLethalHealth1000:
dd 0
dd 0
flag_MULEsLethalHealth0:
dd 0
dd 0
flag_MULEsLethalHealth1000:
dd 0
dd 0
flag_MachineGunDead:
dd 0
dd 0
flag_MachineGunMax:
dd 0
dd 0
Flag_EnemyAmmo0:
dd 0
dd 0
flag_OneHitKillBT:
dd 0
dd 0
flag_Order64_OneHitKillBT:
dd 0
dd 0
flag_Order65Phase1OneHitKill:
dd 0
dd 0
flag_Order65_InfPlayerHealth_PunchOut:
dd 0
dd 0
flag_Order65_PlayerMaxStamina_PunchOut:
dd 0
dd 0
flag_Order65Punchout_Higgs1HitKill:
dd 0
dd 0
flag_AutoPaverMaterials8000:
dd 0
dd 0
flag_InfEquipmentUse:
dd 0
dd 0
flag_RepairAllStructures:
dd 0
dd 0
flag_RepairAllRoads:
dd 0
dd 0
flag_0StructureBuildTime:
dd 0
dd 0
flag_BTOilNoHP:
dd 0
dd 0
flag_BTOilHPGainBack:
dd 0
dd 0
flag_AllSmallCargo:
dd 0
dd 0
flag_InfDrillTrainingTimer:
dd 0
dd 0
flag_10MinDrillTrainingTimer:
dd 0
dd 0
flag_RaceTrackTotalTime0:
dd 0
dd 0
flag_RaceTrackLapTime0:
dd 0
dd 0
flag_Sandalweed999:
dd 0
dd 0
flag_InfEquipment2:
dd 0
dd 0
flag_RaceTrackInstantWin:
dd 0
dd 0
flag_DontTrip:
dd 0
dd 0
flag_MaxMaterialStorage:
dd 0
dd 0
flag_PCCStructureFacilityMaterials99999:
dd 0
dd 0
flag_PCCMaxMaterialStorage99999:
dd 0
dd 0
flag_NoRecoil:
dd 0
dd 0
flag_RapidFire:
dd 0
dd 0
flag_CliffUngerHealth0:
dd 0
dd 0
flag_IgnoreHits:
dd 0
dd 0
flag_BulletSpeed:
dd 0
dd 0
flag_RateOfFire:
dd 0
dd 0
flag_NoBloodorChiralSpent:
dd 0
dd 0
{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
//Injection Point
PlayerX:
jmp PlayerXInjection
nop 3
ReturnFromPlayerXInjection:
{------------------------------------------------------------------------------}
//Injection Point
VehicleX:
jmp VehicleXInjection
nop 3
ReturnFromVehicleXInjection:
{------------------------------------------------------------------------------}
//Injection Point
WaypointX+01:
jmp WaypointXInjection
ReturnFromWaypointXInjection:
{------------------------------------------------------------------------------}
//Injection Point
CarrierX+03:
jmp CarrierXInjection
nop 3
ReturnFromCarrierXInjection:
{------------------------------------------------------------------------------}
//Injection Point
PlayerBaseStatsAOB:
jmp EnterPlayerStatsInjection
nop 3
ReturnFromPlayerStatsInject:
{------------------------------------------------------------------------------}
//Injection Point
BBStressAOB+04:
jmp EnterBBStressLevelInjection
nop 4
ReturnFromBBStressLevelInject:
{------------------------------------------------------------------------------}
//Injection Point
PlayerBatteryAOB:
jmp EnterPlayerBatteryInjection
nop 3
ReturnFromPlayerBatteryInject:
{------------------------------------------------------------------------------}
//Injection Point
CurrentAMMOAOB:
jmp EnterCurrentAmmoInjection
nop 3
ReturnFromCurrentAmmoInject:
{------------------------------------------------------------------------------}
//Injection Point
BloodBagAOB:
jmp EnterBloodBagInjection
nop 2
ReturnFromBloodBagInject:
{------------------------------------------------------------------------------}
//Injection Point
CurrentWeightAOB:
jmp EnterCurrentWeightInjection
nop 4
ReturnFromCurrentWeightInject:
{------------------------------------------------------------------------------}
//Injection Point
MaxWeightAOB:
jmp EnterMaxWeightInjection
nop 4
ReturnFromMaxWeightInject:
{------------------------------------------------------------------------------}
//Injection Point
UrinationAOB:
jmp EnterUrinationInjection
nop 4
ReturnFromUrinationInject:
{------------------------------------------------------------------------------}
//Injection Point
CryptobioteInBackpackAOB:
jmp EnterCryptobioteInjection
nop
ReturnFromCryptobioteInject:
{------------------------------------------------------------------------------}
//Injection Point
PlayerSuitAOB:
jmp EnterPlayerSuitInjection
nop 3
ReturnFromPlayerSuitInject:
{------------------------------------------------------------------------------}
//Injection Point
BridgesEnergyAOB:
jmp EnterBridgesEnergyInjection
ReturnFromBridgesEnergyInject:
{------------------------------------------------------------------------------}
//Injection Point
ChiralCrystalsInBackpackAOB:
jmp EnterChiralCrystalsInBackpackInjection
nop 3
ReturnFromChiralCrystalsInBackpackInject:
{------------------------------------------------------------------------------}
//Injection Point
FacilityChiralCrystalsAOB:
jmp EnterFacilityChiralCrystalsInjection
ReturnFromFacilityChiralCrystalsInject:
{------------------------------------------------------------------------------}
//Injection Point
VehicleBatteryAOB:
jmp EnterVehicleBatteryInjection
ReturnFromVehicleBatteryInject:
{------------------------------------------------------------------------------}
//Injection Point
VehicleDurabilityAOB:
jmp EnterVehicleDurabilityInjection
nop 3
ReturnFromVehicleDurabilityInject:
{------------------------------------------------------------------------------}
//Injection Point
VehiclePhysicalConditionAOB:
jmp EnterVehiclePhysicalConditionInjection
nop 3
ReturnFromVehiclePhysicalConditionInject:
{------------------------------------------------------------------------------}
//Injection Point
DamageAOB:
jmp EnterDamageInjection
ReturnFromDamage0Inject:
{------------------------------------------------------------------------------}
//Injection Point
ContainerDamageAOB:
jmp EnterContainerDamageInjection
ReturnFromContainerDamage0Inject:
{------------------------------------------------------------------------------}
//Injection Point
CurrentTimeStandardOrdersAOB:
jmp EnterCurrentTimeStandardOrdersInjection
ReturnCurrentTimeStandardOrdersInject:
{------------------------------------------------------------------------------}
//Injection Point
MaxTimeStandardOrdersAOB:
jmp EnterMaxTimeStandardOrdersInjection
nop
ReturnMaxTimeStandardOrdersInject:
{------------------------------------------------------------------------------}
//Injection Point
LikesAOB:
jmp EnterLikesInjection
nop 6
ReturnFromLikesInjection:
{------------------------------------------------------------------------------}
//Injection Point
//MULEsNonLethalHealthAOB:
//jmp EnterMULEsNonLethalHealthInjection
//nop
//ReturnFromMULEsNonLethalHealthInject:
{------------------------------------------------------------------------------}
//Injection Point
MULEsNonLethalHealthAOB2:
jmp EnterMULEsNonLethalHealth2Injection
nop 5
ReturnFromMULEsNonLethalHealth2Inject:
{------------------------------------------------------------------------------}
//Injection Point
MULEsLethalHealthAOB:
jmp EnterMULEsLethalHealthInjection
nop 3
ReturnMULEsLethalHealthInject:
{------------------------------------------------------------------------------}
//Injection Point
MULEsLethalHealthAOB2:
jmp EnterMULEsLethalHealth2Injection
nop 3
ReturnMULEsLethalHealth2Inject:
{------------------------------------------------------------------------------}
//Injection Point
MachineGunAOB:
jmp EnterMachineGunInjection
ReturnFromMachineGunInject:
{------------------------------------------------------------------------------}
//Injection Point
MachineGunCurrentAOB+01:
jmp EnterMachineGunPlayerInjection
ReturnFromMachineGunPlayerInject:
{------------------------------------------------------------------------------}
//Injection Point
EnemyAmmoAOB:
jmp EnterEnemyAmmoInjection
ReturnFromEnemyAmmoInject:
{------------------------------------------------------------------------------}
//Injection Point
BT_OneHitKillAOB:
jmp EnterBTKillInjection
nop 3
ReturnBTHealthInjection:
{------------------------------------------------------------------------------}
//Injection Point
Order64_OneHitKillBTAOB:
jmp EnterOrder64BTKillInjection
nop 3
ReturnFromOrder64_OneHitKillBTInject:
{------------------------------------------------------------------------------}
//Injection Point
Order65BossHealthPhase1AOB:
jmp EnterOrder65BossHealthPhase1Injection
nop 3
ReturnFromOrder65BossHealthPhase1CodeInject:
{------------------------------------------------------------------------------}
//Injection Point
Order65_PlayerHealth_PunchOutAOB:
jmp EnterOrder65_PlayerHealth_PunchOutInjection
nop 3
ReturnFromOrder65_PlayerHealth_PunchOutInject:
{------------------------------------------------------------------------------}
//Injection Point
Order65_PlayerStamina_PunchOutAOB:
jmp EnterOrder65_PlayerStamina_PunchOutInjection
nop
ReturnFromOrder65_PlayerStamina_PunchOutInject:
{------------------------------------------------------------------------------}
//Injection Point
Order65Punchout_HiggsHealthAOB:
jmp EnterOrder65Punchout_HiggsHealthInjection
nop 4
ReturnFromOrder65Punchout_HiggsHealthInject:
{------------------------------------------------------------------------------}
//Injection Point
Order65Punchout_HiggsHealthOHKAOB:
jmp EnterOrder65Punchout_HiggsHealthOHKInjection
nop 3
ReturnFromOrder65Punchout_HiggsHealthOHKInject:
{------------------------------------------------------------------------------}
//Injection Point:
AutoPaverMaterialsAOB:
jmp EnterAutoPaverMaterialsInjection
nop 2
ReturnFromAutoPaverMaterials8000Inject:
{------------------------------------------------------------------------------}
//Injection Point:
EquipmentUseAOB:
jmp EnterEquipmentUseInjection
nop 2
ReturnFromInfEquipmentUseInject:
{------------------------------------------------------------------------------}
//Injection Point:
StructuresDurabilityAOB:
jmp EnterRepairAllStructuresInjection
nop 3
ReturnFromRepairAllStructuresInject:
{------------------------------------------------------------------------------}
//Injection Point:
CurrentStructureDurabilityAOB:
jmp EnterCurrentStructureDurabilityInjection
nop 3
ReturnFromCurrentStructureDurabilityInject:
{------------------------------------------------------------------------------}
//Injection Point:
MaxRoadDurabilityAOB:
jmp EnterRepairAllRoadsInjection
ReturnFromRepairAllRoadsInject:
{------------------------------------------------------------------------------}
//Injection Point:
StructureBuildTimerAOB+01:
jmp EnterStructureBuildTimerInjection
nop 3
ReturnFromStructureBuildTimerInject:
{------------------------------------------------------------------------------}
//Injection Point:
BTsRemoveOilAOB:
jmp EnterBTOilInjection
nop 3
ReturnFromBTOilInject:
{------------------------------------------------------------------------------}
//Injection Point:
AllSmallCargoAOB:
jmp EnterAllSmallCargoInjection
nop 2
ReturnFromAllSmallCargoInject:
{------------------------------------------------------------------------------}
//Injection Point:
ItemIDAOB:
jmp EnterItemIDInjection
nop 3
ReturnFromItemIDInject:
{------------------------------------------------------------------------------}
//Injection Point:
SlotIDAOB:
jmp EnterSlotIDInjection
nop 2
ReturnFromSlotIDInject:
{------------------------------------------------------------------------------}
//Injection Point:
DrillTrainingTimerAOB+05:
jmp EnterDrillTrainingTimerInjection
nop 3
ReturnFromDrillTrainingTimerInject:
{------------------------------------------------------------------------------}
//Injection Point:
RaceTrackTotalTimeAOB:
jmp EnterRaceTrackTotalTimeInjection
nop 3
ReturnFromRaceTrackTotalTimeInject:
{------------------------------------------------------------------------------}
//Injection Point:
SandalweedAOB:
jmp EnterSandalweedInjection
nop 2
ReturnFromSandalweedInject:
{------------------------------------------------------------------------------}
//Injection Point:
DrillTargetsAOB:
jmp EnterDrillTargetsInjection
nop 2
ReturnFromDrillTargetsInject:
{------------------------------------------------------------------------------}
//Injection Point:
RaceTrack_CurrentLapAOB:
jmp EnterRaceTrack_CurrentLapInjection
nop 2
ReturnFromRaceTrack_CurrentLapInject:
{------------------------------------------------------------------------------}
//Injection Point:
DontTripAOB:
jmp EnterDontTripInjection
nop 4
ReturnFromDontTripInject:
{------------------------------------------------------------------------------}
//Injection Point:
MaxMaterialStorageAOB:
jmp EnterMaxMaterialStorageInjection
ReturnFromMaxMaterialStorageInject:
{------------------------------------------------------------------------------}
//Injection Point:
PCCStructureFacilityMaterialsAOB:
jmp EnterPCCStructureFacilityMaterialsInjection
nop 2
ReturnFromPCCStructureFacilityMaterialsInject:
{------------------------------------------------------------------------------}
//Injection Point:
PCCMaxMaterialStorageAOB:
jmp EnterPCCMaxMaterialStorageInjection
nop 4
ReturnFromPCCMaxMaterialStorageInject:
{------------------------------------------------------------------------------}
//Injection Point:
NoRecoilAOB:
jmp EnterNoRecoilInjection
nop 3
ReturnFromNoRecoilInject:
{------------------------------------------------------------------------------}
//Injection Point:
RapidFireAOB:
jmp EnterRapidFireInjection
nop 3
ReturnFromRapidFireInject:
{------------------------------------------------------------------------------}
//Injection Point:
CliffUngerHealthAOB:
jmp EnterCliffUngerHealthInjection
nop 3
ReturnFromCliffUngerHealthInject:
{------------------------------------------------------------------------------}
//Injection Point:
IgnoreHitsAOB:
jmp EnterIgnoreHitsInjection
nop 3
ReturnFromIgnoreHitsInject:
{------------------------------------------------------------------------------}
//Injection Point:
MaxMagazineAmmoAOB:
jmp EnterMaxMagazineAmmoInjection
nop
ReturnFromMaxMagazineAmmoInject:
{------------------------------------------------------------------------------}
//Injection Point:
MaxAmmoAOB:
jmp EnterMaxAmmoInjection
ReturnFromMaxAmmoInject:
{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
[DISABLE]
PlayerX:
db C5 F8 11 87 80 00 00 00
VehicleX:
db C5 FB 10 87 C8 00 00 00
WaypointX+01:
db C5 F8 10 70 10
CarrierX+03:
db C5 F8 10 80 C8 00 00 00
PlayerBaseStatsAOB:
db C5 FA 10 83 C0 00 00 00
BBStressAOB+04:
db C4 C1 7A 10 86 34 43 00 00
PlayerBatteryAOB:
db C5 FA 10 81 10 48 00 00
CurrentAMMOAOB:
db 0F B7 18 E8 5D DC F1 FF
BloodBagAOB:
db 41 8B 85 38 48 00 00
CurrentWeightAOB:
db 8B 41 0C 89 87 C4 00 00 00
MaxWeightAOB:
db C4 C1 7A 10 97 58 0C 00 00
UrinationAOB:
db C4 C1 4A 5F 86 4C 48 00 00
CryptobioteInBackpackAOB:
db 44 8B 00 41 8B CE
PlayerSuitAOB:
db C5 FA 10 81 58 03 00 00
BridgesEnergyAOB:
db C5 FA 10 57 04
ChiralCrystalsInBackpackAOB:
db 41 8B 84 C9 08 24 00 00
FacilityChiralCrystalsAOB:
db 48 8B 44 1A 30
VehicleBatteryAOB:
db C5 78 2F 78 08
VehicleDurabilityAOB:
db C5 FA 10 B1 E8 06 00 00
VehiclePhysicalConditionAOB:
db C5 FA 10 BF 84 00 00 00
DamageAOB:
db C5 FA 10 4A 34
ContainerDamageAOB:
db C5 FA 10 42 30
CurrentTimeStandardOrdersAOB:
db C5 FB 11 43 38
MaxTimeStandardOrdersAOB:
db C4 C1 7A 10 60 14
LikesAOB:
db 49 03 49 18 48 8B 90 80 14 00 00
//MULEsNonLethalHealthAOB:
//db 8B 81 F0 01 00 00
MULEsNonLethalHealthAOB2:
db C5 FA 10 03 C4 C1 7A 5C 4E 04
MULEsLethalHealthAOB:
db C5 FA 10 8B EC 01 00 00
MULEsLethalHealthAOB2:
db C5 FA 10 8E EC 01 00 00
MachineGunAOB:
db C5 FA 10 48 50
MachineGunCurrentAOB+01:
db C5 FA 58 49 50
EnemyAmmoAOB:
db 0F B7 18 33 C0
BT_OneHitKillAOB:
db C5 FA 10 83 3C 01 00 00
Order64_OneHitKillBTAOB:
db C5 FA 10 86 30 01 00 00
Order65BossHealthPhase1AOB:
db C5 78 2F 93 58 01 00 00
Order65_PlayerHealth_PunchOutAOB:
db C5 FA 10 80 DC 00 00 00
Order65_PlayerStamina_PunchOutAOB:
db C5 FA 10 54 37 38
Order65Punchout_HiggsHealthAOB:
db C4 C1 7A 10 96 58 01 00 00
Order65Punchout_HiggsHealthOHKAOB:
db C5 FA 10 80 58 01 00 00
AutoPaverMaterialsAOB:
db 44 8B 89 10 02 00 00
EquipmentUseAOB:
db 44 0F BF 09 0F B6 C0
StructuresDurabilityAOB:
db C5 FA 10 B8 D8 00 00 00
//db C5 F8 2F 81 D8 00 00 00 //old aob
CurrentStructureDurabilityAOB:
db C5 FA 10 88 D8 00 00 00
MaxRoadDurabilityAOB:
db C5 FA 10 40 0C
StructureBuildTimerAOB+01:
db C5 FA 10 8F D8 00 00 00
BTsRemoveOilAOB:
db C5 78 2F 86 3C 01 00 00
AllSmallCargoAOB:
db 0F B6 4B 3E 83 E9 01
ItemIDAOB:
db 48 8B 49 28 48 89 55 2F
SlotIDAOB:
db 48 8B 46 28 45 33 E4
DrillTrainingTimerAOB+05:
db C5 FB 10 81 18 01 00 00
RaceTrackTotalTimeAOB:
db C5 FB 10 88 B0 02 00 00
SandalweedAOB:
db 8B 84 2F 0C 38 00 00
DrillTargetsAOB:
db 8B 43 2C 44 8B 43 24
RaceTrack_CurrentLapAOB:
db 0F B7 88 D4 00 00 00
DontTripAOB:
db 77 1A 80 B9 51 09 00 00 00
MaxMaterialStorageAOB:
db 42 8B 44 81 68
StructureFacilityMaterialsAOB:
db 44 8B 89 7C 02 00 00
PCCMaxMaterialStorageAOB:
db 48 63 48 08 48 89 4C 24 30
NoRecoilAOB:
db C5 FA 11 A1 F4 04 00 00
RapidfireAOB:
db C5 7A 11 87 9C 04 00 00
CliffUngerHealthAOB:
db C5 FA 10 86 60 01 00 00
IgnoreHitsAOB:
db 84 C0 0F 84 51 04 00 00
MaxMagazineAmmoAOB:
db 83 78 58 00 77 0F
MaxAmmoAOB:
db 66 44 89 04 41
unregistersymbol(*)
dealloc(*)
133629
"Pointers"
1
133630
"Player Pointers"
1
133631
"Current Health (Legit Max=1000)"
0
Float
PlayerStats
C0
133632
"Max Health (Legit Max=1000)"
0
Float
PlayerStats
C4
133633
"Current Consciousness (Legit Max=1000)"
0
Float
PlayerStats
DC
133634
"Max Consciousness (Legit Max=1000)"
0
Float
PlayerStats
E8
133635
"Current Stamina (Legit Max=1000)"
0
Float
PlayerStats
110
133636
"Max Stamina (Legit Max=1000)"
0
Float
PlayerStats
104
133637
"Fatigue (0=No Fatigue, 10000=Full Fatigue)"
0
Float
PlayerStats
130
133638
"Endurance (Legit Max=1000)"
0
Float
PlayerStats
140
133639
"Current Boots Durability"
0
Float
PlayerStats
32C
133640
"Max Boots Durability"
0
Float
PlayerStats
330
133641
"Current Player Battery (Legit Max=1000)"
0
Float
PlayerBattery
4810
133642
"Max Player Battery (Legit Max=1000)"
0
Float
PlayerBattery
4804
133643
"BB Stress Bar (0=No Stress)"
0
Float
BBStress
4334
133644
"Current Blood Bag (Amount Stored)"
0
Float
BloodBag
4838
133645
"Max Blood Bag (Amount Stored)"
0
Float
BloodBag
483C
133646
"Current Weight Carried (Doesn't Change Items Weight)"
0
Float
CurrentWeight
0C
133647
"Base Max Carrying Weight Capacity [Base=120]"
0
Float
MaxWeight
C58
133648
"Urination ml (Legit Max= 1000ml)"
0
Float
Urination
484C
133649
"Bridges Energy [Formerly Monster Drink] mL (Legit Max= 1000ml)"
0
Float
BridgesEnergy
04
133650
"Cryptobiote's Stored in Backpack (Legit Max=999)"
0
2 Bytes
Cryptobiote
0
133651
"D-Cryptobiote's Stored in Backpack (Legit Max=999)"
0
2 Bytes
Cryptobiote
48
133652
"Player Suit Condition [Rust] (Legit Max=5000)"
0
Float
PlayerSuit
358
133653
"Optional Backpack Cover Condition [Rust]"
0
Float
PlayerSuit
47A8
133654
"Current Chiral Crystals In Backpack"
0
4 Bytes
ChiralCrystalsInBackpack
0
133655
"Max Chiral Crystals In Backpack"
0
4 Bytes
ChiralCrystalsInBackpack
4
133656
"Sandalweed in Backpack"
0
2 Bytes
Sandalweed
0
133657
"Weapon & Ammo Pointers"
1
133658
"Current Ammo in Magazine (Shoot Current Weapon to Update)"
0
2 Bytes
CurrentAmmo
0
136369
"Current Max Ammo"
0
2 Bytes
MaxAmmo
10A
136370
"Current Ammo [Visual]"
0
2 Bytes
MaxAmmo
108
136322
"[Max] Max Magazine Ammo (Shoot Current Weapon to Update)"
0
4 Bytes
MaxMagazineAmmo
58
136506
"[Weapon Delay Speed] Rate of Fire"
0
Float
WeaponDelaySpeed
49C
136333
"[Weapon Attack Speed] Rate of Fire"
0
Float
MaxMagazineAmmo
78
136334
"Casing Size"
0
Float
MaxMagazineAmmo
54
136332
"Bullet Speed"
0
Float
MaxMagazineAmmo
68
136323
"Chiral/Blood lost per bullet"
0
Float
MaxMagazineAmmo
8C
133659
"Machine Gun Timer [Random machine gun, just to get an address]"
0
Float
MachineGun
50
133660
"Machine Gun Timer [Currently Used]"
0
Float
MachineGunPlayer
50
133661
"Vehicle Pointers"
1
133662
"Current Vehicle Current Battery"
0
Float
VehicleBattery
8
133663
"Current Vehicle Max Battery"
0
Float
VehicleBattery
C
133664
"Current Vehicle Current Durability"
0
Float
VehicleDurability
6E8
133665
"Current Vehicle Maximum Durability"
0
Float
VehicleDurability
6EC
133666
"Current Vehicle Physical Condition (Rust) (0-1, 1=No Rust)"
0
Float
VehiclePhysicalCondition
84
133667
"Teleport Pointers - Coordinates"
1
133668
"Player Coordinates"
1
133669
"X Coordinate"
0
Float
PlayerCoordinates
80
133670
"Y Coordinate"
0
Float
PlayerCoordinates
84
133671
"Z Coordinate"
0
Float
PlayerCoordinates
88
133672
"Vehicle Coordinates (Must be in Vehicle to Prevent Teleporting Other Vehicles)"
1
133673
"X Coordinate (Moving Position)"
0
Double
VehicleCoordinates
C8
133674
"X Coordinate (Original Position)"
0
Double
VehicleCoordinates
8F8
133675
"Y Coordinate (Moving Position)"
0
Double
VehicleCoordinates
D0
133676
"Y Coordinate (Original Position)"
0
Double
VehicleCoordinates
900
133677
"Z Coordinate (Moving Position)"
0
Double
VehicleCoordinates
D8
133678
"Z Coordinate (Original Position)"
0
Double
VehicleCoordinates
908
133679
"Waypoint Coordinates (Last Created)"
1
133680
"X Coordinate"
0
Float
WaypointCoordinates
10
133681
"Y Coordinate"
0
Float
WaypointCoordinates
14
133682
"Z Coordinate"
0
Float
WaypointCoordinates
18
133683
"Carrier Coordinates (Last Attached)"
1
133684
"X Coordinate"
0
Double
CarrierCoordinates
C8
133685
"Y Coordinate"
0
Double
CarrierCoordinates
D0
133686
"Z Coordinate"
0
Double
CarrierCoordinates
D8
133687
"Materials/Facilities/Structures Related"
1
133688
"[Facility Materials] Pointer - Per Location"
0
4 Bytes
"$process"+07C0E480
1168
50
133689
"Capitol Knot City - Chiral Crystals"
0
4 Bytes
-1138
133690
"Capitol Knot City - Resins"
0
4 Bytes
-1130
133691
"Capitol Knot City - Metals"
0
4 Bytes
-1128
133692
"Capitol Knot City - Ceramics"
0
4 Bytes
-1120
133693
"Capitol Knot City - Chemicals"
0
4 Bytes
-1118
133694
"Capitol Knot City - Special Alloys"
0
4 Bytes
-1110
133695
"Chiral Artist's Studio - Chiral Crystals"
0
4 Bytes
-A18
133696
"Chiral Artist's Studio - Resins"
0
4 Bytes
-A10
133697
"Chiral Artist's Studio - Metals"
0
4 Bytes
-A08
133698
"Chiral Artist's Studio - Ceramics"
0
4 Bytes
-A00
133699
"Chiral Artist's Studio - Chemicals"
0
4 Bytes
-9F8
133700
"Chiral Artist's Studio - Special Alloys"
0
4 Bytes
-9F0
133701
"Collector - Chiral Crystals"
0
4 Bytes
-130
133702
"Collector - Chiral Crystals"
0
4 Bytes
-128
133703
"Collector - Chiral Crystals"
0
4 Bytes
-120
133704
"Collector - Chiral Crystals"
0
4 Bytes
-118
133705
"Collector - Chiral Crystals"
0
4 Bytes
-110
133706
"Collector - Chiral Crystals"
0
4 Bytes
-108
133707
"Cosplayer - Chiral Crystals"
0
4 Bytes
-260
133708
"Cosplayer - Resins"
0
4 Bytes
-258
133709
"Cosplayer - Metals"
0
4 Bytes
-250
133710
"Cosplayer - Ceramics"
0
4 Bytes
-248
133711
"Cosplayer - Chemicals"
0
4 Bytes
-240
133712
"Cosplayer - Special Alloys"
0
4 Bytes
-238
133713
"Craftsman - Chiral Crystals"
0
4 Bytes
-BE0
133714
"Craftsman - Resins"
0
4 Bytes
-BD8
133715
"Craftsman - Metals"
0
4 Bytes
-BD0
133716
"Craftsman - Ceramics"
0
4 Bytes
-BC8
133717
"Craftsman - Chemicals"
0
4 Bytes
-BC0
133718
"Craftsman - Special Alloys"
0
4 Bytes
-BB8
133719
"Distribution Center North of Edge Knot City - Chiral Crystals"
0
4 Bytes
+558
133720
"Distribution Center North of Edge Knot City - Resins"
0
4 Bytes
+560
133721
"Distribution Center North of Edge Knot City - Metals"
0
4 Bytes
+568
133722
"Distribution Center North of Edge Knot City - Ceramics"
0
4 Bytes
+570
133723
"Distribution Center North of Edge Knot City - Chemicals"
0
4 Bytes
+578
133724
"Distribution Center North of Edge Knot City - Special Alloys"
0
4 Bytes
+580
133725
"Distribution Center North of Mountain Knot City - Chiral Crystals"
0
4 Bytes
+2F8
133726
"Distribution Center North of Mountain Knot City - Resins"
0
4 Bytes
+300
133727
"Distribution Center North of Mountain Knot City - Metals"
0
4 Bytes
+308
133728
"Distribution Center North of Mountain Knot City - Ceramics"
0
4 Bytes
+310
133729
"Distribution Center North of Mountain Knot City - Chemicals"
0
4 Bytes
+318
133730
"Distribution Center North of Mountain Knot City - Special Alloys"
0
4 Bytes
+320
133731
"Distribution Center South of Lake Knot City - Chiral Crystals"
0
4 Bytes
+98
133732
"Distribution Center South of Lake Knot City - Resins"
0
4 Bytes
+A0
133733
"Distribution Center South of Lake Knot City - Metals"
0
4 Bytes
+A8
133734
"Distribution Center South of Lake Knot City - Ceramics"
0
4 Bytes
+B0
133735
"Distribution Center South of Lake Knot City - Chemicals"
0
4 Bytes
+B8
133736
"Distribution Center South of Lake Knot City - Special Alloys"
0
4 Bytes
+C0
133737
"Distribution Center West of Capital Knot City - Chiral Crystals"
0
4 Bytes
-1008
133738
"Distribution Center West of Capital Knot City - Resins"
0
4 Bytes
-1000
133739
"Distribution Center West of Capital Knot City - Metals"
0
4 Bytes
-FF8
133740
"Distribution Center West of Capital Knot City - Ceramics"
0
4 Bytes
-FF0
133741
"Distribution Center West of Capital Knot City - Chemicals"
0
4 Bytes
-FE8
133742
"Distribution Center West of Capital Knot City - Special Alloys"
0
4 Bytes
-FE0
133743
"Doctor - Chiral Crystals"
0
4 Bytes
-688
133744
"Doctor - Resins"
0
4 Bytes
-680
133745
"Doctor - Metals"
0
4 Bytes
-678
133746
"Doctor - Ceramics"
0
4 Bytes
-670
133747
"Doctor - Chemicals"
0
4 Bytes
-668
133748
"Doctor - Special Alloys"
0
4 Bytes
-660
133749
"Edge Knot City - Chiral Crystals"
0
4 Bytes
+5F0
133750
"Edge Knot City - Resins"
0
4 Bytes
+5F8
133751
"Edge Knot City - Metals"
0
4 Bytes
+600
133752
"Edge Knot City - Ceramics"
0
4 Bytes
+608
133753
"Edge Knot City - Chemicals"
0
4 Bytes
+610
133754
"Edge Knot City - Special Alloys"
0
4 Bytes
+618
133755
"Elder - Chiral Crystals"
0
4 Bytes
-C78
133756
"Elder - Resins"
0
4 Bytes
-C70
133757
"Elder - Metals"
0
4 Bytes
-C68
133758
"Elder - Ceramics"
0
4 Bytes
-C60
133759
"Elder - Chemicals"
0
4 Bytes
-C58
133760
"Elder - Special Alloys"
0
4 Bytes
-C50
133761
"Engineer - Chiral Crystals"
0
4 Bytes
-D10
133762
"Engineer - Resins"
0
4 Bytes
-D08
133763
"Engineer - Metals"
0
4 Bytes
-D00
133764
"Engineer - Ceramics"
0
4 Bytes
-CF8
133765
"Engineer - Chemicals"
0
4 Bytes
-CF0
133766
"Engineer - Special Alloys"
0
4 Bytes
-CE8
133767
"Evo-devo Biologist - Chiral Crystals"
0
4 Bytes
-428
133768
"Evo-devo Biologist - Resins"
0
4 Bytes
-420
133769
"Evo-devo Biologist - Metals"
0
4 Bytes
-418
133770
"Evo-devo Biologist - Ceramics"
0
4 Bytes
-410
133771
"Evo-devo Biologist - Chemicals"
0
4 Bytes
-408
133772
"Evo-devo Biologist - Special Alloys"
0
4 Bytes
-400
133773
"Film Director - Chiral Crystals"
0
4 Bytes
-2F8
133774
"Film Director - Resins"
0
4 Bytes
-2F0
133775
"Film Director - Metals"
0
4 Bytes
-2E8
133776
"Film Director - Ceramics"
0
4 Bytes
-2E0
133777
"Film Director - Chemicals"
0
4 Bytes
-2D8
133778
"Film Director - Special Alloys"
0
4 Bytes
-2D0
133779
"First Prepper - Chiral Crystals"
0
4 Bytes
-1C8
133780
"First Prepper - Resins"
0
4 Bytes
-1C0
133781
"First Prepper - Metals"
0
4 Bytes
-1B8
133782
"First Prepper - Ceramics"
0
4 Bytes
-1B0
133783
"First Prepper - Chemicals"
0
4 Bytes
-1A8
133784
"First Prepper - Special Alloys"
0
4 Bytes
-1A0
133785
"Geologist - Chiral Crystals"
0
4 Bytes
-5F0
133786
"Geologist - Resins"
0
4 Bytes
-5E8
133787
"Geologist - Metals"
0
4 Bytes
-5E0
133788
"Geologist - Ceramics"
0
4 Bytes
-5D8
133789
"Geologist - Chemicals"
0
4 Bytes
-5D0
133790
"Geologist - Special Alloys"
0
4 Bytes
-5C8
133791
"Heartman's Lab - Chiral Crystals"
0
4 Bytes
+428
133792
"Heartman's Lab - Resins"
0
4 Bytes
+430
133793
"Heartman's Lab - Metals"
0
4 Bytes
+438
133794
"Heartman's Lab - Ceramics"
0
4 Bytes
+440
133795
"Heartman's Lab - Chemicals"
0
4 Bytes
+448
133796
"Heartman's Lab - Special Alloys"
0
4 Bytes
+450
133797
"Junk Dealer - Chiral Crystals"
0
4 Bytes
-AB0
133798
"Junk Dealer - Resins"
0
4 Bytes
-AA8
133799
"Junk Dealer - Metals"
0
4 Bytes
-AA0
133800
"Junk Dealer - Ceramics"
0
4 Bytes
-A98
133801
"Junk Dealer - Chemicals"
0
4 Bytes
-A90
133802
"Junk Dealer - Special Alloys"
0
4 Bytes
-A88
133803
"Lake Knot City - Chiral Crystals"
0
4 Bytes
+0
133804
"Lake Knot City - Resins"
0
4 Bytes
+8
133805
"Lake Knot City - Metals"
0
4 Bytes
+10
133806
"Lake Knot City - Ceramics"
0
4 Bytes
+18
133807
"Lake Knot City - Chemicals"
0
4 Bytes
+20
133808
"Lake Knot City - Special Alloys"
0
4 Bytes
+28
133809
"Ludens Fan - Chiral Crystals"
0
4 Bytes
-E40
133810
"Ludens Fan - Resins"
0
4 Bytes
-E38
133811
"Ludens Fan - Metals"
0
4 Bytes
-E30
133812
"Ludens Fan - Ceramics"
0
4 Bytes
-E28
133813
"Ludens Fan - Chemicals"
0
4 Bytes
-E20
133814
"Ludens Fan - Special Alloys"
0
4 Bytes
-E18
133815
"Mama's Lab - Chiral Crystals"
0
4 Bytes
+260
133816
"Mama's Lab - Resins"
0
4 Bytes
+268
133817
"Mama's Lab - Metals"
0
4 Bytes
+270
133818
"Mama's Lab - Ceramics"
0
4 Bytes
+278
133819
"Mama's Lab - Chemicals"
0
4 Bytes
+280
133820
"Mama's Lab - Special Alloys"
0
4 Bytes
+288
133821
"Mountain Knot City - Chiral Crystals"
0
4 Bytes
+390
133822
"Mountain Knot City - Resins"
0
4 Bytes
+398
133823
"Mountain Knot City - Metals"
0
4 Bytes
+3A0
133824
"Mountain Knot City - Ceramics"
0
4 Bytes
+3A8
133825
"Mountain Knot City - Chemicals"
0
4 Bytes
+3B0
133826
"Mountain Knot City - Special Alloys"
0
4 Bytes
+3B8
133827
"Mountaineer - Chiral Crystals"
0
4 Bytes
-850
133828
"Mountaineer - Resins"
0
4 Bytes
-848
133829
"Mountaineer - Metals"
0
4 Bytes
-840
133830
"Mountaineer - Ceramics"
0
4 Bytes
-838
133831
"Mountaineer - Chemicals"
0
4 Bytes
-830
133832
"Mountaineer - Special Alloys"
0
4 Bytes
-828
133833
"Musician - Chiral Crystals"
0
4 Bytes
-DA8
133834
"Musician - Resins"
0
4 Bytes
-DA0
133835
"Musician - Metals"
0
4 Bytes
-D98
133836
"Musician - Ceramics"
0
4 Bytes
-D90
133837
"Musician - Chemicals"
0
4 Bytes
-D88
133838
"Musician - Special Alloys"
0
4 Bytes
-D80
133839
"Novelists's Son - Chiral Crystals"
0
4 Bytes
-98
133840
"Novelists's Son - Resins"
0
4 Bytes
-90
133841
"Novelists's Son - Metals"
0
4 Bytes
-88
133842
"Novelists's Son - Ceramics"
0
4 Bytes
-80
133843
"Novelists's Son - Chemicals"
0
4 Bytes
-78
133844
"Novelists's Son - Special Alloys"
0
4 Bytes
-70
133845
"Paleontologist - Chiral Crystals"
0
4 Bytes
-558
133846
"Paleontologist - Resins"
0
4 Bytes
-550
133847
"Paleontologist - Metals"
0
4 Bytes
-548
133848
"Paleontologist - Ceramics"
0
4 Bytes
-540
133849
"Paleontologist - Chemicals"
0
4 Bytes
-538
133850
"Paleontologist - Special Alloys"
0
4 Bytes
-530
133851
"Peter Englert - Chiral Crystals"
0
4 Bytes
-390
133852
"Peter Englert - Resins"
0
4 Bytes
-388
133853
"Peter Englert - Metals"
0
4 Bytes
-380
133854
"Peter Englert - Ceramics"
0
4 Bytes
-378
133855
"Peter Englert - Chemicals"
0
4 Bytes
-370
133856
"Peter Englert - Special Alloys"
0
4 Bytes
-368
133857
"Photographer - Chiral Crystals"
0
4 Bytes
-7B8
133858
"Photographer - Resins"
0
4 Bytes
-7B0
133859
"Photographer - Metals"
0
4 Bytes
-7A8
133860
"Photographer - Ceramics"
0
4 Bytes
-7A0
133861
"Photographer - Chemicals"
0
4 Bytes
-798
133862
"Photographer - Special Alloys"
0
4 Bytes
-790
133863
"Port Knot City - Chiral Crystals"
0
4 Bytes
-ED8
133864
"Port Knot City - Resins"
0
4 Bytes
-ED0
133865
"Port Knot City - Metals"
0
4 Bytes
-EC8
133866
"Port Knot City - Ceramics"
0
4 Bytes
-EC0
133867
"Port Knot City - Chemicals"
0
4 Bytes
-EB8
133868
"Port Knot City - Special Alloys"
0
4 Bytes
-EB0
133869
"Roboticist - Chiral Crystals"
0
4 Bytes
-8E8
133870
"Roboticist - Resins"
0
4 Bytes
-8E0
133871
"Roboticist - Metals"
0
4 Bytes
-8D8
133872
"Roboticist - Ceramics"
0
4 Bytes
-8D0
133873
"Roboticist - Chemicals"
0
4 Bytes
-8C8
133874
"Roboticist - Special Alloys"
0
4 Bytes
-8C0
133875
"South Knot City - Chiral Crystals"
0
4 Bytes
+1C8
133876
"South Knot City - Resins"
0
4 Bytes
+1D0
133877
"South Knot City - Metals"
0
4 Bytes
+1D8
133878
"South Knot City - Ceramics"
0
4 Bytes
+1E0
133879
"South Knot City - Chemicals"
0
4 Bytes
+1E8
133880
"South Knot City - Special Alloys"
0
4 Bytes
+1F0
133881
"Spiritualist - Chiral Crystals"
0
4 Bytes
-720
133882
"Spiritualist - Resins"
0
4 Bytes
-718
133883
"Spiritualist - Metals"
0
4 Bytes
-710
133884
"Spiritualist - Ceramics"
0
4 Bytes
-708
133885
"Spiritualist - Chemicals"
0
4 Bytes
-700
133886
"Spiritualist - Special Alloys"
0
4 Bytes
-6F8
133887
"Timefall Farm - Chiral Crystals"
0
4 Bytes
-B48
133888
"Timefall Farm - Resins"
0
4 Bytes
-B40
133889
"Timefall Farm - Metals"
0
4 Bytes
-B38
133890
"Timefall Farm - Ceramics"
0
4 Bytes
-B30
133891
"Timefall Farm - Chemicals"
0
4 Bytes
-B28
133892
"Timefall Farm - Special Alloys"
0
4 Bytes
-B20
133893
"Veteran Porter - Chiral Crystals"
0
4 Bytes
-4C0
133894
"Veteran Porter - Resins"
0
4 Bytes
-4B8
133895
"Veteran Porter - Metals"
0
4 Bytes
-4B0
133896
"Veteran Porter - Ceramics"
0
4 Bytes
-4A8
133897
"Veteran Porter - Chemicals"
0
4 Bytes
-4A0
133898
"Veteran Porter - Special Alloys"
0
4 Bytes
-498
133899
"Waystation North of Mountain Knot City - Chiral Crystals"
0
4 Bytes
-980
133900
"Waystation North of Mountain Knot City - Resins"
0
4 Bytes
-978
133901
"Waystation North of Mountain Knot City - Metals"
0
4 Bytes
-970
133902
"Waystation North of Mountain Knot City - Ceramics"
0
4 Bytes
-968
133903
"Waystation North of Mountain Knot City - Chemicals"
0
4 Bytes
-960
133904
"Waystation North of Mountain Knot City - Special Alloys"
0
4 Bytes
-958
133905
"Waystation West of Capital Knot City - Chiral Crystals"
0
4 Bytes
-10A0
133906
"Waystation West of Capital Knot City - Resins"
0
4 Bytes
-1098
133907
"Waystation West of Capital Knot City - Metals"
0
4 Bytes
-1090
133908
"Waystation West of Capital Knot City - Ceramics"
0
4 Bytes
-1088
133909
"Waystation West of Capital Knot City - Chemicals"
0
4 Bytes
-1080
133910
"Waystation West of Capital Knot City - Special Alloys"
0
4 Bytes
-1078
133911
"Weather Station - Chiral Crystals"
0
4 Bytes
+130
133912
"Weather Station - Resins"
0
4 Bytes
+138
133913
"Weather Station - Metals"
0
4 Bytes
+140
133914
"Weather Station - Ceramics"
0
4 Bytes
+148
133915
"Weather Station - Chemicals"
0
4 Bytes
+150
133916
"Weather Station - Special Alloys"
0
4 Bytes
+158
133917
"Wind Farm - Chiral Crystals"
0
4 Bytes
-F70
133918
"Wind Farm - Resins"
0
4 Bytes
-F68
133919
"Wind Farm - Metals"
0
4 Bytes
-F60
133920
"Wind Farm - Ceramics"
0
4 Bytes
-F58
133921
"Wind Farm - Chemicals"
0
4 Bytes
-F50
133922
"Wind Farm - Special Alloys"
0
4 Bytes
-F48
133923
"[Facility Materials] AOB - Any Facility & Preppers [Open Terminal & It Will Update Addresses]"
1
133924
"Chiral Crystals"
0
4 Bytes
FacilityChiralCrystals
-28
133925
"Resins"
0
4 Bytes
FacilityChiralCrystals
-20
133926
"Metals"
0
4 Bytes
FacilityChiralCrystals
-18
133927
"Ceramics"
0
4 Bytes
FacilityChiralCrystals
-10
133928
"Chemicals"
0
4 Bytes
FacilityChiralCrystals
-8
133929
"Special Alloys"
0
4 Bytes
FacilityChiralCrystals
0
133930
"[Safe House Materials] AOB - Any PCC Terminal [Open Terminal & It Will Update Addresses]"
1
133931
"Chiral Crystals"
0
4 Bytes
PCCStructureFacilityMaterials
0
133932
"Resins"
0
4 Bytes
PCCStructureFacilityMaterials
4
133933
"Metals"
0
4 Bytes
PCCStructureFacilityMaterials
8
133934
"Ceramics"
0
4 Bytes
PCCStructureFacilityMaterials
C
133935
"Chemicals"
0
4 Bytes
PCCStructureFacilityMaterials
10
133936
"Special Alloys"
0
4 Bytes
PCCStructureFacilityMaterials
14
133937
"Current Structure - Amount of Materials Already Used By You"
1
133938
"You still need at least one material required to upgrade structure"
0000FF
1
133939
"Chiral Crystals"
0
2 Bytes
AutoPaverMaterials
210
133940
"Resins"
0
2 Bytes
AutoPaverMaterials
214
133941
"Metals"
0
2 Bytes
AutoPaverMaterials
218
133942
"Ceramics"
0
2 Bytes
AutoPaverMaterials
21C
133943
"Chemicals"
0
2 Bytes
AutoPaverMaterials
220
133944
"Special Alloys"
0
2 Bytes
AutoPaverMaterials
224
133945
"Current Structure Type"
0
Byte
CurrentStructureDurability
35
133946
"Current Structure Level (resets on reload)"
0
Byte
CurrentStructureDurability
84
133947
"Current Structure Durability"
0
Float
CurrentStructureDurability
D8
133948
"Amount of Time for Current Structure to Build"
0
Float
StructureBuildTimer
D8
133949
"Road Durability (Random Address, just to grab one for instructions)"
0
Float
RoadDurability
0C
133950
"Timer"
1
133951
"Current Time for Urgent Standard Order (Value In Seconds Going Upwards)"
0
Double
CurrentTimeStandardOrders
38
133952
"Max Time For Urgent Standard Mission (Value in Seconds)"
0
Float
MaxTimeStandardOrders
14
133953
"Likes [Open Cuff Links "Map" & It Will Update Addresses]"
1
136469
"Likes Received (NPCs)"
0
8 Bytes
Likes
18
133955
"Likes Received (Other Players) - Delivery Stats Menu"
0
8 Bytes
Likes
20
133956
"Total Likes from Other Players - Social (Other Players) Menu"
0
8 Bytes
Likes
60
133957
"Total Likes Given to Other Players"
0
8 Bytes
Likes
68
133958
"Boss/Enemy Addresses"
1
133959
"[1F0] MULE Non-Lethal Current Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
1F0
133960
"MULE Non-Lethal Max Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
1E0
133961
"MULE Lethal Current Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
1EC
133962
"MULE Lethal Max Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
1DC
136480
"[0] MULE Non-Lethal Current Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
0
136481
"MULE Non-Lethal Max Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
-10
136482
"MULE Lethal Current Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
-4
136483
"MULE Lethal Max Health [Last Attacked Using Non-Lethal Ammo]"
0
Float
MULEsNonLethalHealth2
-14
133963
"MULE Lethal Current Health [Last Attacked Using Lethal Ammo]"
0
Float
MULEsLethalHealth2
1EC
133964
"MULE Lethal Max Health [Last Attacked Using Lethal Ammo]"
0
Float
MULEsLethalHealth2
1DC
133965
"MULE Non-Lethal Current Health [Last Attacked Using Lethal Ammo]"
0
Float
MULEsLethalHealth2
1F0
133966
"MULE Non-Lethal Max Health [Last Attacked Using Lethal Ammo]"
0
Float
MULEsLethalHealth2
1E0
136468
"MULE Lethal & Non-Lethal Health [Random Mule just to get an address]"
1
136464
"MULE Lethal Current Health [random mule just to get an address]"
0
Float
MULEsLethalHealth
1EC
136465
"MULE Lethal Max Health [random mule just to get an address]"
0
Float
MULEsLethalHealth
1DC
136466
"MULE Non-Lethal Current Health [random mule just to get an address]"
0
Float
MULEsLethalHealth
1F0
136467
"MULE Non-Lethal Max Health [random mule just to get an address]"
0
Float
MULEsLethalHealth
1E0
133967
"MULE Current Ammo [Random MULE, just to get an address]"
0
2 Bytes
EnemyAmmo
0
133968
"BT Current Health - All Except Order 64 Boss BT [Last Attacked BT]"
0
Float
BTHealth
13C
133969
"BT Max Health - All Except Order 64 Boss BT [Last Attacked BT]"
0
Float
BTHealth
138
133970
"Episode 9 - Order 64 - BT Boss Current Health"
0
Float
Order64_BossHP
130
133971
"Episode 9 - Order 64 - BT Boss Max Health"
0
Float
Order64_BossHP
134
133972
"Episode 9 - Order 65 Phase 1 [Shootout & Hand-to-Hand] - Boss Current Health"
0
Float
Order65BossHealthPhase1
158
133973
"Episode 9 - Order 65 Phase 1 [Shootout] - Boss Max Health"
0
Float
Order65BossHealthPhase1
160
133974
"Episode 9 - Order 65 Phase 1 [Hand-to-Hand] - Boss Max Health"
0
Float
Order65BossHealthPhase1
164
133975
"Episode 9 - Order 65 Phase 2 [Punch Out] - Boss Current Health"
0
Float
Order65Punchout_HiggsHealth
158
133976
"Episode 9 - Order 65 Phase 2 [Punch Out] - Boss Max Health"
0
Float
Order65Punchout_HiggsHealth
168
133977
"Episode 9 - Order 65 Phase 2 [Punch Out] - Player Current Health"
0
Float
Order65_PlayerHealth_PunchOut
DC
133978
"Episode 9 - Order 65 Phase 2 [Punch Out] - Player Max Health"
0
Float
Order65_PlayerHealth_PunchOut
E4
133979
"Episode 9 - Order 65 Phase 2 [Punch Out] - Player Current Stamina - [Have to Lock]"
0
Float
Order65_PlayerStamina_PunchOut
0
133980
"Cliff Unger Health"
0
Float
CliffUngerHealth
160
133981
"Currently Selected Cargo Editor"
1
133982
"SlotID"
0
8 Bytes
SlotID
28
133983
"ItemID"
0
8 Bytes
ItemID
28
133984
"Type ( 0=Lost Cargo/Boots, 1=Tools/Weapons, 4=Materials)"
0
Byte
ItemID
3D
133985
"Size [0-3] 0=Small, 3=XL //Change to XL+Higher Weight for more Likes"
0:Small
1:Medium
2:Large
3:XL
0
Byte
ItemID
3E
133986
"Weight"
0
Float
ItemID
50
133987
"Current Cargo Damage"
0
Float
SlotID
34
133988
"Max Cargo Damage"
0
4 Bytes
ItemID
5C
133989
"Current Cargo Container Damage"
0
Float
SlotID
30
133990
"Max Container Damage"
0
4 Bytes
ItemID
58
133991
"Current Ammo"
0
2 Bytes
SlotID
108
133992
"[Current] Max Ammo"
0
2 Bytes
SlotID
10A
133993
"[Max] Max Ammo"
0
Float
SlotID
100
133994
"Firing Range Pointers"
1
133995
"Current Drill Time Remaining"
0
4 Bytes
DrillTrainingTimer
11C
133996
"Current Drill Score"
0
4 Bytes
DrillTrainingTimer
364
133997
"Ammo Conservation Score before deduction "
0
4 Bytes
DrillTrainingTimer
3C
133998
"Score deduction for shooting incorrect target"
0
4 Bytes
DrillTrainingTimer
368
133999
"Total Targets Needed (able to be changed)"
0
4 Bytes
DrillTrainingTimer
36C
134000
"Shots Fired"
0
4 Bytes
DrillTrainingTimer
350
134001
"ammo conservation score deduction"
0
4 Bytes
DrillTrainingTimer
388
134002
"Current Targets Done - Visual Only"
0
0000FF
4 Bytes
DrillTargets
2C
134003
"Current Targets Done (Alternate) - Visual Only"
0
0000FF
4 Bytes
DrillTargets
38
134004
"Total Targets Needed - Visual Only"
0
0000FF
4 Bytes
DrillTargets
24
134005
"Total Targets Needed (Alternate) - Visual Only"
0
0000FF
4 Bytes
DrillTargets
28
134006
"Race Track Pointers"
1
134007
"Race Track - Current Lap"
0
Byte
RaceTrack_CurrentLap
D4
134008
"Race Track Total Time - 1004496743 = 0 Seconds"
0
Double
RaceTrackTotalTime
2B0
134009
"Race Track Total Time - 1004496743 = 0 Seconds"
0
4 Bytes
RaceTrackTotalTime
2B4
134010
"Race Track Lap Time - 1004496743 = 0 Seconds"
0
Double
RaceTrackTotalTime
2B8
134011
"Race Track Lap Time - 1004496743 = 0 Seconds"
0
4 Bytes
RaceTrackTotalTime
2BC
134012
"Scripts"
1
134013
"Player Stats Scripts"
1
134014
"Infinite+Max = Health, Consciousness, Stamina, 0 Fatique, Endurance, 0 BB Stress & Battery"
Auto Assembler Script
[ENABLE]
flag_InfPlayerHealth:
dd 1
flag_InfConsciousness:
dd 1
flag_InfStamina:
dd 1
flag_NoFatigue:
dd 1
flag_InfEndurance:
dd 1
flag_NoBBStress:
dd 1
flag_InfPlayerBattery:
dd 1
[DISABLE]
flag_InfPlayerHealth:
dd 0
flag_InfConsciousness:
dd 0
flag_InfStamina:
dd 0
flag_NoFatigue:
dd 0
flag_InfEndurance:
dd 0
flag_NoBBStress:
dd 0
flag_InfPlayerBattery:
dd 0
134015
"Infinite+Max Health"
Auto Assembler Script
[ENABLE]
flag_InfPlayerHealth:
dd 1
[DISABLE]
flag_InfPlayerHealth:
dd 0
134016
"Infinite+Max Consciousness"
Auto Assembler Script
[ENABLE]
flag_InfConsciousness:
dd 1
[DISABLE]
flag_InfConsciousness:
dd 0
134017
"Infinite+Max Stamina"
Auto Assembler Script
[ENABLE]
flag_InfStamina:
dd 1
[DISABLE]
flag_InfStamina:
dd 0
134018
"0 Fatigue"
Auto Assembler Script
[ENABLE]
flag_NoFatigue:
dd 1
[DISABLE]
flag_NoFatigue:
dd 0
134019
"Full Fatigue"
Auto Assembler Script
[ENABLE]
flag_FullFatigue:
dd 1
[DISABLE]
flag_FullFatigue:
dd 0
134020
"Infinite+Max Endurance"
Auto Assembler Script
[ENABLE]
flag_InfEndurance:
dd 1
[DISABLE]
flag_InfEndurance:
dd 0
134021
"0 BB Stress"
Auto Assembler Script
[ENABLE]
flag_NoBBStress:
dd 1
[DISABLE]
flag_NoBBStress:
dd 0
134024
"Infinite+Max Player Battery"
Auto Assembler Script
[ENABLE]
flag_InfPlayerBattery:
dd 1
[DISABLE]
flag_InfPlayerBattery:
dd 0
134022
"Boots Durability set to Legit Max every 60 seconds (Stop the constant beeping) [change timer as desired]"
Auto Assembler Script
{$lua}
if syntaxcheck then return end
[ENABLE]
Badasstimer = createTimer()
Badasstimer.setInterval(60000)
Badasstimer.onTimer = function(Badass)
local modAddy = readFloat('[PlayerStats]+330') -- We store the pointer of this address into local variable modAddy
writeFloat('[PlayerStats]+32C',modAddy) -- We write the pointer of modAddy to the pointer at this address
end
[DISABLE]
Badasstimer.destroy()
134023
"Infinite Boots Durability [Set to Legitimate Max of Equipped Item]"
Auto Assembler Script
[ENABLE]
flag_MaxBootsDurability:
dd 1
[DISABLE]
flag_MaxBootsDurability:
dd 0
134025
"Infinite Blood Bag (Legitimate Max)"
Auto Assembler Script
[ENABLE]
flag_InfBloodBag:
dd 1
[DISABLE]
flag_InfBloodBag:
dd 0
134026
"0 Weight Carried [Prevents Shifting Weight] (Doesn't Change Items Weight)"
Auto Assembler Script
[ENABLE]
flag_0CurrentWeight:
dd 1
[DISABLE]
flag_0CurrentWeight:
dd 0
134027
"Don't Trip / Remain Balanced"
Auto Assembler Script
[ENABLE]
flag_DontTrip:
dd 1
[DISABLE]
flag_DontTrip:
dd 0
134028
"Base Max Carrying Weight Capacity 5000 [it will reset when you reload save]"
Auto Assembler Script
[ENABLE]
flag_InfMaxWeight:
dd 1
[DISABLE]
flag_InfMaxWeight:
dd 0
134029
"Urination (mL) to Full"
Auto Assembler Script
[ENABLE]
flag_MaxUrination:
dd 1
[DISABLE]
flag_MaxUrination:
dd 0
134030
"Urination (mL) to Empty"
Auto Assembler Script
[ENABLE]
flag_NoUrination:
dd 1
[DISABLE]
flag_NoUrination:
dd 0
134031
"Infinite+Max Bridges Energy [Formerly Monster Drink]"
Auto Assembler Script
[ENABLE]
flag_InfBridgesEnergy:
dd 1
[DISABLE]
flag_InfBridgesEnergy:
dd 0
134032
"Infinite+Max(999) Cryptobiote's"
Auto Assembler Script
[ENABLE]
flag_MaxCryptobiote:
dd 1
[DISABLE]
flag_MaxCryptobiote:
dd 0
134033
"Infinite+Max(999) D-Cryptobiote's"
Auto Assembler Script
[ENABLE]
flag_MaxDCryptobiote:
dd 1
[DISABLE]
flag_MaxDCryptobiote:
dd 0
134034
"Clean Player Suit (Doesn't Remove Blood)"
Auto Assembler Script
[ENABLE]
flag_CleanPlayerSuit:
dd 1
[DISABLE]
flag_CleanPlayerSuit:
dd 0
134035
"Clean Optional Backpack Cover"
Auto Assembler Script
[ENABLE]
flag_OptionalBackpackCoverClean:
dd 1
[DISABLE]
flag_OptionalBackpackCoverClean:
dd 0
134036
"Infinite+Max Chiral Crystals In Backpack"
Auto Assembler Script
[ENABLE]
flag_MaxChiralCrystalsInBackpack:
dd 1
[DISABLE]
flag_MaxChiralCrystalsInBackpack:
dd 0
134037
"Infinite+999 Sandalweed"
Auto Assembler Script
[ENABLE]
flag_Sandalweed999:
dd 1
[DISABLE]
flag_Sandalweed999:
dd 0
136282
"Cargo - Damage, etc."
1
136283
"Prevent Cargo Fall Damage (Recommended If Using Teleporting Scripts)"
Auto Assembler Script
{ Game : ds.exe
Version:
Date : 2024-09-06
Author : pc
This script does blah blah blah
}
[ENABLE]
aobscanmodule(PreventCargoFallDamageAOB,ds.exe,C4 C1 7A 11 4E 34 * * * * 75) // should be unique
alloc(newmem,$1000,PreventCargoFallDamageAOB)
label(code)
label(return)
newmem:
code:
//vmovss [r14+34],xmm1
jmp return
PreventCargoFallDamageAOB:
jmp newmem
nop
return:
registersymbol(PreventCargoFallDamageAOB)
[DISABLE]
PreventCargoFallDamageAOB:
db C4 C1 7A 11 4E 34
unregistersymbol(PreventCargoFallDamageAOB)
dealloc(newmem)
{
// ORIGINAL CODE - INJECTION POINT: ds.exe+2C2DAB2
ds.exe+2C2DA7F: C4 41 7A 10 56 34 - vmovss xmm10,[r14+34]
ds.exe+2C2DA85: C4 41 78 2F D3 - vcomiss xmm10,xmm11
ds.exe+2C2DA8A: C4 C1 78 28 F9 - vmovaps xmm7,xmm9
ds.exe+2C2DA8F: 0F 86 A1 0D 00 00 - jbe ds.exe+2C2E836
ds.exe+2C2DA95: C4 41 78 2F CB - vcomiss xmm9,xmm11
ds.exe+2C2DA9A: 0F 86 96 0D 00 00 - jbe ds.exe+2C2E836
ds.exe+2C2DAA0: 41 80 7E 20 05 - cmp byte ptr [r14+20],05
ds.exe+2C2DAA5: 41 B7 01 - mov r15l,01
ds.exe+2C2DAA8: C4 C1 2A 5C C1 - vsubss xmm0,xmm10,xmm9
ds.exe+2C2DAAD: C4 C1 7A 5F CB - vmaxss xmm1,xmm0,xmm11
// ---------- INJECTING HERE ----------
ds.exe+2C2DAB2: C4 C1 7A 11 4E 34 - vmovss [r14+34],xmm1
// ---------- DONE INJECTING ----------
ds.exe+2C2DAB8: C5 AA 5C F9 - vsubss xmm7,xmm10,xmm1
ds.exe+2C2DABC: 75 0D - jne ds.exe+2C2DACB
ds.exe+2C2DABE: 44 8B F9 - mov r15d,ecx
ds.exe+2C2DAC1: 41 C1 EF 10 - shr r15d,10
ds.exe+2C2DAC5: 41 80 E7 01 - and r15l,01
ds.exe+2C2DAC9: EB 68 - jmp ds.exe+2C2DB33
ds.exe+2C2DACB: 49 8B 46 28 - mov rax,[r14+28]
ds.exe+2C2DACF: 80 78 3B 0A - cmp byte ptr [rax+3B],0A
ds.exe+2C2DAD3: 75 0A - jne ds.exe+2C2DADF
ds.exe+2C2DAD5: 41 80 BE 80 00 00 00 0F - cmp byte ptr [r14+00000080],0F
}
136286
"0% Damage & Container Damage [Legit Max] (Carried on Back & Tool Rack)"
Auto Assembler Script
{ Game : $process
Author : Anon-9
This script sets non-special slots to Max durability
}
[ENABLE]
aobscanmodule(fPerfectDurability,$process,C5 FA 10 5A 34) // should be unique
alloc(newmem,$1000,fPerfectDurability)
label(code)
label(return)
newmem:
code:
cvtsi2ss xmm3,[rax+58] //should be max dura
vmovss [rdx+30],xmm3 //goods damage
cvtsi2ss xmm3,[rax+54] //5C?
//vmovss xmm3,[rdx+34] //original code.
vmovss [rdx+34],xmm3 //container damage.
jmp return
fPerfectDurability:
jmp newmem
return:
registersymbol(fPerfectDurability)
[DISABLE]
fPerfectDurability:
db C5 FA 10 5A 34
unregistersymbol(fPerfectDurability)
dealloc(newmem)
//new $process+2C5896B
{
// ORIGINAL CODE - INJECTION POINT: $process+298EA3B
$process+298EA10: 49 8B 03 - mov rax,[r11]
$process+298EA13: 4C 8B 40 18 - mov r8,[rax+18]
$process+298EA17: 48 63 40 10 - movsxd rax,dword ptr [rax+10]
$process+298EA1B: 4D 8D 0C C0 - lea r9,[r8+rax*8]
$process+298EA1F: 4D 3B C1 - cmp r8,r9
$process+298EA22: 0F 84 AA 00 00 00 - je $process+298EAD2
$process+298EA28: 0F 1F 84 00 00 00 00 00 - nop dword ptr [rax+rax+00000000]
$process+298EA30: 49 8B 10 - mov rdx,[r8]
$process+298EA33: C5 E8 57 D2 - vxorps xmm2,xmm2,xmm2
$process+298EA37: 48 8B 42 28 - mov rax,[rdx+28]
// ---------- INJECTING HERE ----------
$process+298EA3B: C5 FA 10 5A 34 - vmovss xmm3,[rdx+34]
// ---------- DONE INJECTING ----------
$process+298EA40: C5 E2 58 03 - vaddss xmm0,xmm3,[rbx]
$process+298EA44: 8B 48 54 - mov ecx,[rax+54]
$process+298EA47: C4 E1 EA 2A D1 - vcvtsi2ss xmm2,rdx,rcx
$process+298EA4C: C5 F8 2F D4 - vcomiss xmm2,xmm4
$process+298EA50: C5 FA 11 03 - vmovss [rbx],xmm0
$process+298EA54: C4 C1 6A 58 4D 00 - vaddss xmm1,xmm2,[r13+00]
$process+298EA5A: C4 C1 7A 11 4D 00 - vmovss [r13+00],xmm1
$process+298EA60: 76 12 - jna $process+298EA74
$process+298EA62: C4 C1 7A 10 02 - vmovss xmm0,[r10]
$process+298EA67: C5 E2 5E CA - vdivss xmm1,xmm3,xmm2
}
136287
"0% Damage & Container Damage [Legit Max] (Offloaded/Not Carried)"
Auto Assembler Script
{ Game : $process
Version:
Date : 2022-05-03
Author : Anon-9
Updated: crashin73331
This script does blah blah blah
}
[ENABLE]
aobscanmodule(OffloadCargoDurabilityAOB,$process,C5 F8 2F 77 34 72 CB) // should be unique
alloc(newmem,$1000,OffloadCargoDurabilityAOB)
label(code)
label(return)
newmem:
code:
cvtsi2ss xmm6,[rax+58] //should be max dura
vmovss [rdi+30],xmm6 //cargo damage
cvtsi2ss xmm6,[rax+5C]
//vcomiss xmm6,[rdi+34] // original code
vmovss [rdi+34],xmm6 //cargo container damage
jmp return
OffloadCargoDurabilityAOB:
jmp newmem
return:
registersymbol(OffloadCargoDurabilityAOB)
[DISABLE]
OffloadCargoDurabilityAOB:
db C5 F8 2F 77 34
unregistersymbol(OffloadCargoDurabilityAOB)
dealloc(newmem)
{
// ORIGINAL CODE - INJECTION POINT: $process+2C87E40
$process+2C87E24: 45 84 C9 - test r9l,r9l
$process+2C87E27: 75 22 - jne $process+2C87E4B
$process+2C87E29: 8B 87 04 02 00 00 - mov eax,[rdi+00000204]
$process+2C87E2F: C1 E8 05 - shr eax,05
$process+2C87E32: A8 01 - test al,01
$process+2C87E34: 75 15 - jne $process+2C87E4B
$process+2C87E36: 32 C0 - xor al,al
$process+2C87E38: EB 17 - jmp $process+2C87E51
$process+2C87E3A: 45 32 C9 - xor r9l,r9l
$process+2C87E3D: 0F B6 D1 - movzx edx,cl
// ---------- INJECTING HERE ----------
$process+2C87E40: C5 F8 2F 77 34 - vcomiss xmm6,[rdi+34]
// ---------- DONE INJECTING ----------
$process+2C87E45: 72 CB - jb $process+2C87E12
$process+2C87E47: B0 40 - mov al,40
$process+2C87E49: EB C9 - jmp $process+2C87E14
$process+2C87E4B: B0 80 - mov al,-80
$process+2C87E4D: 41 0F B6 D0 - movzx edx,r8l
$process+2C87E51: 80 E1 7F - and cl,7F
$process+2C87E54: 0A C8 - or cl,al
$process+2C87E56: 88 4B 38 - mov [rbx+38],cl
$process+2C87E59: 80 7F 20 05 - cmp byte ptr [rdi+20],05
$process+2C87E5D: 75 55 - jne $process+2C87EB4
}
136285
"0% Damage & Container Damage [Legit Max] - All Cargo (Excluding Not Carried/Offloaded) (open Cargo Management to catch all addresses)"
Auto Assembler Script
{ Game : $process
Version:
Date : 2022-05-03
Author : crashin73331
This script does blah blah blah
}
[ENABLE]
aobscanmodule(AllCargoDurabilityAOB,$process,C5 FA 10 41 34 * * * * * * * * 77) // should be unique
alloc(newmem,$1000,AllCargoDurabilityAOB)
label(code)
label(return)
newmem:
cmp word ptr [rcx+80],#1
jne code
cvtsi2ss xmm0,[rax+58] //Max Container Damage Durability
vmovss [rcx+30],xmm0 //goods damage
cvtsi2ss xmm0,[rax+5C] //Max Damage Durability
//vmovss xmm0,[rcx+34] //original code.
vmovss [rcx+34],xmm0 //container damage.
code:
vmovss xmm0,[rcx+34] //original code.
jmp return
AllCargoDurabilityAOB:
jmp newmem
return:
registersymbol(AllCargoDurabilityAOB)
[DISABLE]
AllCargoDurabilityAOB:
db C5 FA 10 41 34
unregistersymbol(*)
dealloc(*)
{
// ORIGINAL CODE - INJECTION POINT: $process+2C53961
$process+2C53940: 48 8B 41 28 - mov rax,[rcx+28]
$process+2C53944: C5 E8 57 D2 - vxorps xmm2,xmm2,xmm2
$process+2C53948: C5 F0 57 C9 - vxorps xmm1,xmm1,xmm1
$process+2C5394C: 8B 50 54 - mov edx,[rax+54]
$process+2C5394F: C4 E1 EA 2A D2 - vcvtsi2ss xmm2,rdx,rdx
$process+2C53954: C5 F8 2E D1 - vucomiss xmm2,xmm1
$process+2C53958: 7A 07 - jp $process+2C53961
$process+2C5395A: 75 05 - jne $process+2C53961
$process+2C5395C: C5 F8 57 C0 - vxorps xmm0,xmm0,xmm0
$process+2C53960: C3 - ret
// ---------- INJECTING HERE ----------
$process+2C53961: C5 FA 10 41 34 - vmovss xmm0,[rcx+34]
// ---------- DONE INJECTING ----------
$process+2C53966: C5 FA 5E D2 - vdivss xmm2,xmm0,xmm2
$process+2C5396A: C5 F8 2F CA - vcomiss xmm1,xmm2
$process+2C5396E: 77 0C - ja $process+2C5397C
$process+2C53970: C5 FA 10 05 DC 65 F2 00 - vmovss xmm0,[$process+3B79F54]
$process+2C53978: C5 FA 5D CA - vminss xmm1,xmm0,xmm2
$process+2C5397C: C5 F8 28 C1 - vmovaps xmm0,xmm1
$process+2C53980: C3 - ret
$process+2C53981: CC - int 3
$process+2C53982: CC - int 3
$process+2C53983: CC - int 3
}
136284
"0% Damage & Container Damage [Legit Max] - All Cargo (Including Not Carried/Offloaded) (open Cargo Management to catch all addresses)"
Auto Assembler Script
{ Game : $process
Version:
Date : 2022-05-03
Author : crashin73331
This script does blah blah blah
}
[ENABLE]
aobscanmodule(AllCargoDurabilityAOB,$process,C5 FA 10 41 34 * * * * * * * * 77) // should be unique
alloc(newmem,$1000,AllCargoDurabilityAOB)
label(code)
label(return)
newmem:
code:
//cmp word ptr [rcx+80],#12
//je return
cvtsi2ss xmm0,[rax+58] //Max Container Damage Durability
vmovss [rcx+30],xmm0 //goods damage
cvtsi2ss xmm0,[rax+5C] //Max Damage Durability
//vmovss xmm0,[rcx+34] //original code.
vmovss [rcx+34],xmm0 //container damage.
jmp return
AllCargoDurabilityAOB:
jmp newmem
return:
registersymbol(AllCargoDurabilityAOB)
[DISABLE]
AllCargoDurabilityAOB:
db C5 FA 10 41 34
unregistersymbol(*)
dealloc(*)
{
// ORIGINAL CODE - INJECTION POINT: $process+2C53961
$process+2C53940: 48 8B 41 28 - mov rax,[rcx+28]
$process+2C53944: C5 E8 57 D2 - vxorps xmm2,xmm2,xmm2
$process+2C53948: C5 F0 57 C9 - vxorps xmm1,xmm1,xmm1
$process+2C5394C: 8B 50 54 - mov edx,[rax+54]
$process+2C5394F: C4 E1 EA 2A D2 - vcvtsi2ss xmm2,rdx,rdx
$process+2C53954: C5 F8 2E D1 - vucomiss xmm2,xmm1
$process+2C53958: 7A 07 - jp $process+2C53961
$process+2C5395A: 75 05 - jne $process+2C53961
$process+2C5395C: C5 F8 57 C0 - vxorps xmm0,xmm0,xmm0
$process+2C53960: C3 - ret
// ---------- INJECTING HERE ----------
$process+2C53961: C5 FA 10 41 34 - vmovss xmm0,[rcx+34]
// ---------- DONE INJECTING ----------
$process+2C53966: C5 FA 5E D2 - vdivss xmm2,xmm0,xmm2
$process+2C5396A: C5 F8 2F CA - vcomiss xmm1,xmm2
$process+2C5396E: 77 0C - ja $process+2C5397C
$process+2C53970: C5 FA 10 05 DC 65 F2 00 - vmovss xmm0,[$process+3B79F54]
$process+2C53978: C5 FA 5D CA - vminss xmm1,xmm0,xmm2
$process+2C5397C: C5 F8 28 C1 - vmovaps xmm0,xmm1
$process+2C53980: C3 - ret
$process+2C53981: CC - int 3
$process+2C53982: CC - int 3
$process+2C53983: CC - int 3
}
136288
"Turn All Cargo S [Small]"
Auto Assembler Script
[ENABLE]
flag_AllSmallCargo:
dd 1
[DISABLE]
flag_AllSmallCargo:
dd 0
136256
"Weapon & Damage Scripts"
1
136257
"Infinite Ammo - No Reload (Player Only)"
Auto Assembler Script
[ENABLE]
flag_InfAmmo:
dd 1
[DISABLE]
flag_InfAmmo:
dd 0
136258
"No Recoil"
Auto Assembler Script
[ENABLE]
flag_NoRecoil:
dd 1
[DISABLE]
flag_NoRecoil:
dd 0
136259
"[Weapon Shooting Delay] Rapid Fire (use with No Blood or Chiral Spent From Bullets)"
Auto Assembler Script
[ENABLE]
flag_RapidFire:
dd 1
[DISABLE]
flag_RapidFire:
dd 0
136351
"[Weapon Speed] Rapid Fire (use with No Blood or Chiral Spent From Bullets)"
Auto Assembler Script
[ENABLE]
flag_RateOfFire:
dd 1
[DISABLE]
flag_RateOfFire:
dd 0
136352
"No Blood or Chiral Spent From Bullets"
Auto Assembler Script
[ENABLE]
flag_NoBloodorChiralSpent:
dd 1
[DISABLE]
flag_NoBloodorChiralSpent:
dd 0
136353
"Max Bullet Speed"
Auto Assembler Script
[ENABLE]
flag_BulletSpeed:
dd 1
[DISABLE]
flag_BulletSpeed:
dd 0
136260
"Infinite Equipment/Weapon Use [Set to 10 - Weapons, Ladders, Container Spray, PCC, Anchors etc]"
Auto Assembler Script
[ENABLE]
flag_InfEquipmentUse:
dd 1
[DISABLE]
flag_InfEquipmentUse:
dd 0
136261
"Machine Gun Overheated [Can't Fire, stops MULEs from using]"
Auto Assembler Script
[ENABLE]
flag_MachineGunDead:
dd 1
[DISABLE]
flag_MachineGunDead:
dd 0
136262
"Infinite Machine Gun (yours only)"
Auto Assembler Script
[ENABLE]
flag_MachineGunMax:
dd 1
[DISABLE]
flag_MachineGunMax:
dd 0
136263
"Ignore Hits/Invulnerable // Credits to Anon9 for finding original on DS v1.06 and Sunbeam for updating to v1.01"
Auto Assembler Script
[ENABLE]
flag_IgnoreHits:
dd 1
[DISABLE]
flag_IgnoreHits:
dd 0
0
""Invisible"/Enemies don't attack, part 1 [Note: MULEs scanner still goes off and they detect you, they just don't attack]"
Auto Assembler Script
{
Game : ds.exe
Version:
Date : 2022-04-21
Author : pc
Update : SunBeam
}
[ENABLE]
aobscanmodule(InvisibilityAOB,ds.exe,C4 C1 7A 11 86 04 02 00 00 41) // should be unique
alloc(newmem,$1000,InvisibilityAOB)
label(code)
label(return)
label(hop)
newmem:
mov [r14+204],4B18967F
jmp short hop
code:
vmovss [r14+204],xmm0
hop:
jmp return
InvisibilityAOB:
jmp newmem
nop 4
return:
registersymbol(InvisibilityAOB)
[DISABLE]
InvisibilityAOB:
db C4 C1 7A 11 86 04 02 00 00
unregistersymbol(InvisibilityAOB)
dealloc(newmem)
1
""Invisible"/Enemies don't attack, part 2 [Note: MULEs scanner still goes off and they detect you, they just don't attack]"
Auto Assembler Script
{
Game : ds.exe
Version:
Date : 2022-04-21
Author : pc
Update : SunBeam
}
[ENABLE]
aobscanmodule(Invisibility2AOB,ds.exe,83 BF 10 01 00 00 05 0F 85 8F) // should be unique
alloc(newmem,$1000,Invisibility2AOB)
label(code)
label(return)
newmem:
mov [rdi+110],3
code:
cmp dword ptr [rdi+110],5
jmp return
Invisibility2AOB:
jmp newmem
nop 2
return:
registersymbol(Invisibility2AOB)
[DISABLE]
Invisibility2AOB:
db 83 BF 10 01 00 00 05
unregistersymbol(Invisibility2AOB)
dealloc(newmem)
136265
"No Ammo [Enemy Only] - (Works On Episode 9 - Order 65 - Phase 1 Fight & Clifford)"
Auto Assembler Script
[ENABLE]
Flag_EnemyAmmo0:
dd 1
[DISABLE]
Flag_EnemyAmmo0:
dd 0
136266
"Episode 9 - Order65 Phase 2 [Punch Out] - Player Infinite Health"
Auto Assembler Script
[ENABLE]
flag_Order65_InfPlayerHealth_PunchOut:
dd 1
[DISABLE]
flag_Order65_InfPlayerHealth_PunchOut:
dd 0
136267
"Episode 9 - Order65 Phase 2 [Punch Out] - Palyer Infinite Stamina"
Auto Assembler Script
[ENABLE]
flag_Order65_PlayerMaxStamina_PunchOut:
dd 1
[DISABLE]
flag_Order65_PlayerMaxStamina_PunchOut:
dd 0
136268
"Respawns BTs continiously, escape area after you've killed what you wanT"
1
136269
"Note: freezes your controls on [at least] episode 2 boss where you have to restart game, save beforehand on others"
0000FF
1
136270
"[keep respawning] BTs - Pause Fight & Remove Oil [Disables after 20 seconds, or do it manually, must disable to continue to next script]"
Auto Assembler Script
[ENABLE]
flag_BTOilNoHP:
dd 1
{$lua}
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 20000,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
flag_BTOilNoHP:
dd 0
136271
"BTs - Restart Fight (Auto-Disables)"
Auto Assembler Script
[ENABLE]
flag_BTOilHPGainBack:
dd 1
{$lua}
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[DISABLE]
flag_BTOilHPGainBack:
dd 0
136272
"One Hit Kill Scripts"
1
136273
"One Hit Kill - MULEs [Non-Lethal]"
Auto Assembler Script
[ENABLE]
flag_MULEsNonLethalHealth0:
dd 1
[DISABLE]
flag_MULEsNonLethalHealth0:
dd 0
136274
"All MULEs wake up with Full (Non-Lethal) Health [Disable afterwards, gives MULEs infinite non-lethal health]"
Auto Assembler Script
[ENABLE]
flag_MULEsNonLethalHealth1000:
dd 1
[DISABLE]
flag_MULEsNonLethalHealth1000:
dd 0
136275
"One Hit Kill - MULEs [Lethal] (and unger minions)"
Auto Assembler Script
[ENABLE]
flag_MULEsLethalHealth0:
dd 1
[DISABLE]
flag_MULEsLethalHealth0:
dd 0
136276
"Put MULEs Health back to full that you haven't killed yet after using MULEs One Hit Kill [Lethal] [Disable afterwards, gives MULEs infinite lethal health]"
Auto Assembler Script
[ENABLE]
flag_MULEsLethalHealth1000:
dd 1
[DISABLE]
flag_MULEsLethalHealth1000:
dd 0
136277
"One Hit Kill - All BT's"
Auto Assembler Script
[ENABLE]
flag_OneHitKillBT:
dd 1
flag_Order64_OneHitKillBT:
dd 1
[DISABLE]
flag_OneHitKillBT:
dd 0
flag_Order64_OneHitKillBT:
dd 0
136278
"One Hit Kill - Cliff Unger"
Auto Assembler Script
[ENABLE]
flag_CliffUngerHealth0:
dd 1
[DISABLE]
flag_CliffUngerHealth0:
dd 0
136279
"One Hit Kill - Episode 9 - Order 65 Phase 1 [Shootout & Hand-to-Hand]"
Auto Assembler Script
[ENABLE]
flag_Order65Phase1OneHitKill:
dd 1
[DISABLE]
flag_Order65Phase1OneHitKill:
dd 0
136280
"One Hit Kill - Episode 9 - Order 65 Phase 2 [Punchout] (read below note)"
0000FF
Auto Assembler Script
[ENABLE]
flag_Order65Punchout_Higgs1HitKill:
dd 1
[DISABLE]
flag_Order65Punchout_Higgs1HitKill:
dd 0
136281
"there's a scripted event after boss reaches 200 health that you have to do"
1
134038
"Vehicle Scripts"
1
134039
"Infinite Current Vehicle Battery"
Auto Assembler Script
[ENABLE]
flag_InfVehicleBattery:
dd 1
[DISABLE]
flag_InfVehicleBattery:
dd 0
134040
"Infinite Current Vehicle Durability [Reactivate if you switch vehicles] (Recommended If Using Vehicle Teleporting Scripts)"
Auto Assembler Script
[ENABLE]
flag_InfiniteVehicleDurability:
dd 1
[DISABLE]
flag_InfiniteVehicleDurability:
dd 0
134041
"Clean Current Vehicle Physical Condition (Rust Removal)"
Auto Assembler Script
[ENABLE]
flag_InfVehiclePhysicalCondition:
dd 1
[DISABLE]
flag_InfVehiclePhysicalCondition:
dd 0
136289
"Timers"
1
136290
"0 Seconds Spent on all Urgent Standard Orders"
Auto Assembler Script
[ENABLE]
flag_CurrentTimeStandardOrders0:
dd 1
[DISABLE]
flag_CurrentTimeStandardOrders0:
dd 0
136291
"100 Minutes Max Time on all Urgent Standard Orders"
Auto Assembler Script
[ENABLE]
flag_MaxTimeStandardOrders100Min:
dd 1
[DISABLE]
flag_MaxTimeStandardOrders100Min:
dd 0
136292
"Materials/Facility/Structures Related"
1
136293
"Infinite+99,999 Facilities & Preppers Terminal Materials [Open the Terminal/Claim Materials First to get Pointers] enable then disable"
Auto Assembler Script
[ENABLE]
flag_InfFacilityChiralCrystals:
dd 1
flag_MaxMaterialStorage:
dd 1
[DISABLE]
flag_InfFacilityChiralCrystals:
dd 0
flag_MaxMaterialStorage:
dd 0
136294
"Infinite+99,999 PCC (Safehouse) Terminal Materials [Open the Terminal First to get Pointers]"
Auto Assembler Script
[ENABLE]
flag_PCCStructureFacilityMaterials99999:
dd 1
flag_PCCMaxMaterialStorage99999:
dd 1
[DISABLE]
flag_PCCStructureFacilityMaterials99999:
dd 0
flag_PCCMaxMaterialStorage99999:
dd 0
136295
"[All Structures] - set all materials already used to 15000 [read notes] - Useful for roads"
0000FF
Auto Assembler Script
[ENABLE]
flag_AutoPaverMaterials8000:
dd 1
[DISABLE]
flag_AutoPaverMaterials8000:
dd 0
136296
"Don't use this if you haven't already built all roads or don't plan on building them all now"
0000FF
1
136297
"Option 1: you can either keep this enabled and save game/reload latest save data for it to automatically build"
1
136298
"Option 2: Enable it after you get to the "add materials" screen and then add any 1 material"
1
136299
"Repair All Roads"
Auto Assembler Script
[ENABLE]
flag_RepairAllRoads:
dd 1
[DISABLE]
flag_RepairAllRoads:
dd 0
136300
"Repair All Structures Built By You [Ladders, Timefall Shelter, Zip-lines, etc)"
Auto Assembler Script
[ENABLE]
flag_RepairAllStructures:
dd 1
[DISABLE]
flag_RepairAllStructures:
dd 0
136301
"Instant Structure Build"
Auto Assembler Script
[ENABLE]
flag_0StructureBuildTime:
dd 1
[DISABLE]
flag_0StructureBuildTime:
dd 0
136302
"Infinite Chiral Bandwidth"
Auto Assembler Script
{
credits to Anon9 for finding DS v1.06 version
}
[ENABLE]
aobscanmodule(InfiniteChiralBandwidthAOB,$process,74 51 44 8B B6 14 A6 56 00) // should be unique
alloc(newmem,$1000,InfiniteChiralBandwidthAOB)
label(code)
label(return)
newmem:
jmp $process+2C58716
code:
//je $process+2C58716
mov r14d,[rsi+0056A614]
jmp return
InfiniteChiralBandwidthAOB:
jmp newmem
nop 4
return:
registersymbol(InfiniteChiralBandwidthAOB)
[DISABLE]
InfiniteChiralBandwidthAOB:
db 74 51 44 8B B6 14 A6 56 00
unregistersymbol(InfiniteChiralBandwidthAOB)
dealloc(newmem)
{
// ORIGINAL CODE - INJECTION POINT: $process+2C586C3
$process+2C5869F: 41 8B DE - mov ebx,r14d
$process+2C586A2: 48 63 44 24 38 - movsxd rax,dword ptr [rsp+38]
$process+2C586A7: 48 8D 0C 87 - lea rcx,[rdi+rax*4]
$process+2C586AB: 4C 8B F9 - mov r15,rcx
$process+2C586AE: 4C 2B FF - sub r15,rdi
$process+2C586B1: 49 83 C7 03 - add r15,03
$process+2C586B5: 49 C1 EF 02 - shr r15,02
$process+2C586B9: 48 3B F9 - cmp rdi,rcx
$process+2C586BC: 4D 0F 47 FE - cmova r15,r14
$process+2C586C0: 4D 85 FF - test r15,r15
// ---------- INJECTING HERE ----------
$process+2C586C3: 74 51 - je $process+2C58716
// ---------- DONE INJECTING ----------
$process+2C586C5: 44 8B B6 14 A6 56 00 - mov r14d,[rsi+0056A614]
$process+2C586CC: 0F 1F 40 00 - nop dword ptr [rax+00]
$process+2C586D0: 8B 07 - mov eax,[rdi]
$process+2C586D2: 48 8D 54 24 20 - lea rdx,[rsp+20]
$process+2C586D7: 48 8D 8E 08 A6 56 00 - lea rcx,[rsi+0056A608]
$process+2C586DE: 89 44 24 20 - mov [rsp+20],eax
$process+2C586E2: E8 B9 CF D1 FE - call $process+19756A0
$process+2C586E7: 83 F8 FF - cmp eax,-01
$process+2C586EA: 41 8B CE - mov ecx,r14d
$process+2C586ED: 0F 45 C8 - cmovne ecx,eax
}
136303
"Firing Range Scripts"
1
136304
"Infinite+Max Drill Time Remaining (99 Minutes)"
Auto Assembler Script
[ENABLE]
flag_InfDrillTrainingTimer:
dd 1
[DISABLE]
flag_InfDrillTrainingTimer:
dd 0
136305
"Infinite+Max Drill Time Remaining (10 Minutes)"
Auto Assembler Script
[ENABLE]
flag_10MinDrillTrainingTimer:
dd 1
[DISABLE]
flag_10MinDrillTrainingTimer:
dd 0
136306
"Race Track Scripts"
1
136307
"Race Track - Instant Win Rank S [0 time]"
Auto Assembler Script
[ENABLE]
flag_RaceTrackInstantWin:
dd 1
[DISABLE]
flag_RaceTrackInstantWin:
dd 0
134042
"Teleport Scripts - Locations"
1
136254
"Teleport Player to Waypoint"
Auto Assembler Script
{$lua}
if syntaxcheck then return end
[ENABLE]
X1 = readFloat('[WaypointCoordinates]+10')
if X1 < 0 or X1 > 0
then
local modAddy = readPointer('[WaypointCoordinates]+10') -- We store the pointer of this address into local variable modAddy
writePointer('[PlayerCoordinates]+80',modAddy) -- We write the pointer of modAddy to the pointer at this address
local modAddy = readPointer('[WaypointCoordinates]+14') -- We store the pointer of this address into local variable modAddy
writePointer('[PlayerCoordinates]+84',modAddy) -- We write the pointer of modAddy to the pointer at this address
--local modAddy = readPointer('[WaypointCoordinates]+18') -- We store the pointer of this address into local variable modAddy
--writePointer('[PlayerCoordinates]+88',modAddy) -- We write the pointer of modAddy to the pointer at this address
local modAddy = getAddress('[WaypointCoordinates]+18')
writeFloat('[PlayerCoordinates]+88', readFloat(modAddy) + 2) -- increase z by 2 so you don't get stuck in the ground
-- credits to G40sty at CTG for helping with this change
end
if not syntaxcheck then -- this to end is just to deselect the script.. Un X the box. This is 100% optional
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136242
"Create Your Own Teleport Scripts"
1
136243
"Create a Player Coordinate printout (Credits to kraqurjak)"
Auto Assembler Script
{$lua}
if syntaxcheck then return end
[ENABLE]
GetLuaEngine().MenuItem5.doClick() -- Clears Lua Engine
print"{$lua}"
print"[ENABLE]"
print""
-- <-Change All pointers to your X Y and Z Cords -> --
XCoord = "[PlayerCoordinates]+80" -- Do Not Remove The "
YCoord = "[PlayerCoordinates]+84" -- Do Not Remove The "
ZCoord = "[PlayerCoordinates]+88" -- Do Not Remove The "
X = "writeFloat('"..XCoord.."',"..(readFloat(""..XCoord.."")..") -- X Coord") -- Store Pointer To X
print (X) -- Print X String
Y = "writeFloat('"..YCoord.."',"..(readFloat(""..YCoord.."")..") -- Y Coord") -- Store Pointer To Y
print (Y) -- Print Y String
Z = "writeFloat('"..ZCoord.."',"..(readFloat(""..ZCoord.."")..") -- Z Coord") -- Store Pointer To Z
print (Z) -- Print Z String
print ""
--(Optional) Makes Script Activate But Remain Unchecked So you Can Use Again With Hotkey And Not Have To Uncheck First In New Script
--print "return 'nop'"
--Another option to Auto Un X Box.. This would allow you to Un X after a set amount of time. This is set to 500ms - Change to whatever timer you want
print [[if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end]]
print""
print"[DISABLE]"
-- (Optional) Makes Script Activate But Remain Unchecked So you Can Use Again With Hotkey And Not Have To Uncheck First
return 'nop'
-- (Optional) Could use timer instead
--if not syntaxcheck then
-- synchronize(function()
-- local t = createTimer()
-- t.Interval,t.OnTimer = 500,function(tm)
-- tm.Destroy()
-- memrec.Active = false
-- end
-- end)
--end
[DISABLE]
136244
"Create a Vehicle Coordinate printout (Credits to kraqurjak)"
Auto Assembler Script
{$lua}
if syntaxcheck then return end
[ENABLE]
GetLuaEngine().MenuItem5.doClick() -- Clears Lua Engine
print"{$lua}"
print"[ENABLE]"
print""
-- <-Change All pointers to your X Y and Z Cords -> --
XCoord1 = "[VehicleCoordinates]+C8" -- Do Not Remove The "
XCoord2 = "[VehicleCoordinates]+8F8" -- Do Not Remove The "
YCoord1 = "[VehicleCoordinates]+D0" -- Do Not Remove The "
YCoord2 = "[VehicleCoordinates]+900" -- Do Not Remove The "
ZCoord1 = "[VehicleCoordinates]+D8" -- Do Not Remove The "
ZCoord2 = "[VehicleCoordinates]+908" -- Do Not Remove The "
X1 = "writeFloat('"..XCoord1.."',"..(readDouble(""..XCoord1.."")..") -- X1 Coord") -- Store Pointer To X1
print (X1) -- Print X1 String
X2 = "writeFloat('"..XCoord2.."',"..(readDouble(""..XCoord2.."")..") -- X2 Coord") -- Store Pointer To X2
print (X2) -- Print X2 String
Y1 = "writeFloat('"..YCoord1.."',"..(readDouble(""..YCoord1.."")..") -- Y1 Coord") -- Store Pointer To Y1
print (Y1) -- Print Y1 String
Y2 = "writeFloat('"..YCoord2.."',"..(readDouble(""..YCoord2.."")..") -- Y2 Coord") -- Store Pointer To Y2
print (Y2) -- Print Y2 String
Z1 = "writeFloat('"..ZCoord1.."',"..(readDouble(""..ZCoord1.."")..") -- Z1 Coord") -- Store Pointer To Z1
print (Z1) -- Print Z1 String
Z2 = "writeFloat('"..ZCoord2.."',"..(readDouble(""..ZCoord2.."")..") -- Z2 Coord") -- Store Pointer To Z2
print (Z2) -- Print Z2 String
print ""
--(Optional) Makes Script Activate But Remain Unchecked So you Can Use Again With Hotkey And Not Have To Uncheck First In New Script
--print "return 'nop'"
--Another option to Auto Un X Box.. This would allow you to Un X after a set amount of time. This is set to 500ms - Change to whatever timer you want
print [[if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end]]
print""
print"[DISABLE]"
-- (Optional) Makes Script Activate But Remain Unchecked So you Can Use Again With Hotkey And Not Have To Uncheck First
return 'nop'
-- (Optional) Could use timer instead
--if not syntaxcheck then
-- synchronize(function()
-- local t = createTimer()
-- t.Interval,t.OnTimer = 500,function(tm)
-- tm.Destroy()
-- memrec.Active = false
-- end
-- end)
--end
[DISABLE]
136245
"Create a Player Coordinate Script (Credits to kraqurjak and TheyCallMeTim13)"
Auto Assembler Script
{$lua}
if syntaxcheck then return end
[ENABLE]
local script = {} -- Creates container (script) so we have a container to store script in using table.insert(script,)
table.insert(script, "{$lua}") -- Sending {$lua} To New script
table.insert(script, "[ENABLE]") -- Sending DISABLE To New script
table.insert(script, "") -- Sending Space To New Script
-- <-Change All 3 Pointers Match Your X Y and Z Pointers -> --
XCoord = "[PlayerCoordinates]+80" -- Do Not Remove The "
YCoord = "[PlayerCoordinates]+84" -- Do Not Remove The "
ZCoord = "[PlayerCoordinates]+88" -- Do Not Remove The "
X = "writeFloat('"..XCoord.."',"..(readFloat(""..XCoord.."")..") -- X Coord") -- Store Pointer To X
table.insert(script, X) -- Send Value Of What's Inside X To New Script Because We Don't Have "" Around X To Define It As A String
Y = "writeFloat('"..YCoord.."',"..(readFloat(""..YCoord.."")..") -- Y Coord") -- Store Pointer To Y
table.insert(script, Y) -- Send Value Of What's Inside Y To New Script Because We Don't Have "" Around Y To Define It As A String
Z = "writeFloat('"..ZCoord.."',"..(readFloat(""..ZCoord.."")..") -- Z Coord") -- Store Pointer To Z
table.insert(script, Z) -- Send Value Of What's Inside Z To New Script Because We Don't Have "" Around Z To Define It As A String
table.insert(script, "") -- Sending Space To New Script
-- This will disable the script after 500ms so you dont have to keep unchecking it (adds this timer to saved script)
-- Sends timer To New Script Everything Between [[ ]]
table.insert(script, [[if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end]])
table.insert(script, "") -- Sending Space To New Script
table.insert(script, "[DISABLE]") -- Sending DISABLE To New script
MRLoc = AddressList.getMemoryRecordByDescription('Add New Locations Player') -- Where You Want Saves To Go and put into MRLoc
local mr = AddressList.createMemoryRecord() -- Creates Memory Record (New Entry In CE) and stored it into mr
mr.Type = vtAutoAssembler -- Makes mr (New Entry) An Auto Assembler Script
mr.appendToEntry(MRLoc) -- adds MRloc (Locations Script Will GO) to mr (New Script)
mr.Description = 'Teleport to: ' -- Name of mr (New Script)
mr.Script = table.concat(script, '\n') -- Sends Everything with Table.insert (script,) to mr (New Script)
-- This will disable the script after 500ms so you dont have to keep unchecking it (Timer For This Script)
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false -- This Is The Part Of The Timer That Unchecks The Script
end
end)
end
[DISABLE]
136246
"Create a Vehicle Coordinate Script (Credits to kraqurjak and TheyCallMeTim13)"
Auto Assembler Script
{$lua}
if syntaxcheck then return end
[ENABLE]
local script = {} -- Creates container (script) so we have a container to store script in using table.insert(script,)
table.insert(script, "{$lua}") -- Sending {$lua} To New script
table.insert(script, "[ENABLE]") -- Sending DISABLE To New script
table.insert(script, "") -- Sending Space To New Script
-- <-Change All pointers to your X Y and Z Cords -> --
XCoord1 = "[VehicleCoordinates]+C8" -- Do Not Remove The "
XCoord2 = "[VehicleCoordinates]+8F8" -- Do Not Remove The "
YCoord1 = "[VehicleCoordinates]+D0" -- Do Not Remove The "
YCoord2 = "[VehicleCoordinates]+900" -- Do Not Remove The "
ZCoord1 = "[VehicleCoordinates]+D8" -- Do Not Remove The "
ZCoord2 = "[VehicleCoordinates]+908" -- Do Not Remove The "
X1 = "writeDouble('"..XCoord1.."',"..(readDouble(""..XCoord1.."")..") -- X Coord1") -- Store Pointer To X1
table.insert(script, X1) -- Send Value Of What's Inside X1 To New Script Because We Don't Have "" Around X1 To Define It As A String
X2 = "writeDouble('"..XCoord2.."',"..(readDouble(""..XCoord2.."")..") -- X Coord2") -- Store Pointer To X2
table.insert(script, X2) -- Send Value Of What's Inside X2 To New Script Because We Don't Have "" Around X2 To Define It As A String
Y1 = "writeDouble('"..YCoord1.."',"..(readDouble(""..YCoord1.."")..") -- Y Coord1") -- Store Pointer To Y1
table.insert(script, Y1) -- Send Value Of What's Inside Y1 To New Script Because We Don't Have "" Around Y1 To Define It As A String
Y2 = "writeDouble('"..YCoord2.."',"..(readDouble(""..YCoord2.."")..") -- Y Coord2") -- Store Pointer To Y2
table.insert(script, Y2) -- Send Value Of What's Inside Y2 To New Script Because We Don't Have "" Around Y2 To Define It As A String
Z1 = "writeDouble('"..ZCoord1.."',"..(readDouble(""..ZCoord1.."")..") -- Z Coord1") -- Store Pointer To Z1
table.insert(script, Z1) -- Send Value Of What's Inside Z1 To New Script Because We Don't Have "" Around Z1 To Define It As A String
Z2 = "writeDouble('"..ZCoord2.."',"..(readDouble(""..ZCoord2.."")..") -- Z Coord2") -- Store Pointer To Z2
table.insert(script, Z2) -- Send Value Of What's Inside Z2 To New Script Because We Don't Have "" Around Z2 To Define It As A String
table.insert(script, "") -- Sending Space To New Script
-- This will disable the script after 500ms so you dont have to keep unchecking it (adds this timer to saved script)
-- Sends timer To New Script Everything Between [[ ]]
table.insert(script, [[if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end]])
table.insert(script, "") -- Sending Space To New Script
table.insert(script, "[DISABLE]") -- Sending DISABLE To New script
MRLoc = AddressList.getMemoryRecordByDescription('Add New Locations Vehicle') -- Where You Want Saves To Go and put into MRLoc
local mr = AddressList.createMemoryRecord() -- Creates Memory Record (New Entry In CE) and stored it into mr
mr.Type = vtAutoAssembler -- Makes mr (New Entry) An Auto Assembler Script
mr.appendToEntry(MRLoc) -- adds MRloc (Locations Script Will GO) to mr (New Script)
mr.Description = 'Teleport to: ' -- Name of mr (New Script)
mr.Script = table.concat(script, '\n') -- Sends Everything with Table.insert (script,) to mr (New Script)
-- This will disable the script after 500ms so you dont have to keep unchecking it (Timer For This Script)
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false -- This Is The Part Of The Timer That Unchecks The Script
end
end)
end
[DISABLE]
136247
"Add New Locations Player"
1
136248
"Teleport to: "
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1006.6188964844) -- X Coord
writeFloat('[PlayerCoordinates]+84',868.97216796875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',137.78482055664) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136249
"Teleport to: "
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',611.58361816406) -- X Coord
writeFloat('[PlayerCoordinates]+84',-260.26776123047) -- Y Coord
writeFloat('[PlayerCoordinates]+88',159.36399841309) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136420
"Teleport to: "
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-899.95635986328) -- X Coord
writeFloat('[PlayerCoordinates]+84',1519.0882568359) -- Y Coord
writeFloat('[PlayerCoordinates]+88',458.37017822266) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136441
"Teleport to: "
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1520.4178466797) -- X Coord
writeFloat('[PlayerCoordinates]+84',1468.5122070313) -- Y Coord
writeFloat('[PlayerCoordinates]+88',243.66192626953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136486
"Teleport to: "
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1138.3858642578) -- X Coord
writeFloat('[PlayerCoordinates]+84',1628.2490234375) -- Y Coord
writeFloat('[PlayerCoordinates]+88',237.80166625977) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136487
"Teleport to: "
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1323.4451904297) -- X Coord
writeFloat('[PlayerCoordinates]+84',1872.8342285156) -- Y Coord
writeFloat('[PlayerCoordinates]+88',212.69320678711) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136250
"Add New Locations Vehicle"
1
136251
"Checkpoint 1"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',50.110080238213) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',50.110080238213) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1963.0607621006) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1963.0607621006) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',98.712374034008) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',98.712374034008) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136252
"Checkpoint 2"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',253.97822570801) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',253.97822570801) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-2138.7099609375) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-2138.7099609375) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',118.22048314774) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',118.22048314774) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136253
"end of lap"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',126.94054183873) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',126.94054183873) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1990.8356793966) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1990.8356793966) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',99.680886947947) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',99.680886947947) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134043
"Facilities & Prepper Locations"
1
134044
"Player"
1
134045
"Eastern Region"
1
134046
"Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134047
"Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134048
"Incinerator West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 547.2946777)
writeFloat('[PlayerCoordinates]+84', 360.9596252)
writeFloat('[PlayerCoordinates]+88', 237.9401093)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134049
"Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 101.4508591)
writeFloat('[PlayerCoordinates]+84', 539.0170288)
writeFloat('[PlayerCoordinates]+88', 207.0962372)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134050
"Musician"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -980.53302)
writeFloat('[PlayerCoordinates]+84', -120.1126404)
writeFloat('[PlayerCoordinates]+88', 184.5494537)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134051
"Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134052
"Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',343.82635498047) -- X Coord
writeFloat('[PlayerCoordinates]+84',592.18804931641) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.88571166992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134053
"Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134054
"Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134055
"Central Region"
1
134056
"Aaron Hill's Safe House"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2634.5837402344)
writeFloat('[PlayerCoordinates]+84', -2039.8686523438)
writeFloat('[PlayerCoordinates]+88', 86.349998474121)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134057
"Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134058
"Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134059
"Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134060
"Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134061
"Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134062
"Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134063
"Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134064
"Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134065
"Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134066
"Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134067
"Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134068
"First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134069
"Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134070
"Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134071
"Incinerator West of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -322.81805419922)
writeFloat('[PlayerCoordinates]+84', 2191.2136230469)
writeFloat('[PlayerCoordinates]+88', 218.59948730469)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134072
"Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134073
"Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134074
"Mama's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1022.6657714844)
writeFloat('[PlayerCoordinates]+84', -982.8818359375)
writeFloat('[PlayerCoordinates]+88', 163.03210449219)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134075
"Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134076
"Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134077
"Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2441.5659179688)
writeFloat('[PlayerCoordinates]+84', 1291.0874023438)
writeFloat('[PlayerCoordinates]+88', 251.06520080566)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134078
"Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134079
"Peter Englert"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1749.9689941406)
writeFloat('[PlayerCoordinates]+84', 1971.5640869141)
writeFloat('[PlayerCoordinates]+88', 211.4801940918)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134080
"Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134081
"Racetrack Terminal"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',137.00241088867) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1987.1622314453) -- Y Coord
writeFloat('[PlayerCoordinates]+88',100.44399261475) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134082
"Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134083
"Ruined Shelter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1326.4937744141)
writeFloat('[PlayerCoordinates]+84', 1787.4482421875)
writeFloat('[PlayerCoordinates]+88', 200.16622924805)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134084
"South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134085
"Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134086
"Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134087
"Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134088
"UCA-41-011: Chiral Relay (Potential Chiral Relay Construction Site)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2557.8117675781)
writeFloat('[PlayerCoordinates]+84', -2013.41796875)
writeFloat('[PlayerCoordinates]+88', 93.716613769531)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134089
"Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134090
"Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134091
"Western Region"
1
134092
"Distribution Center North of Edge Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -189.4738922)
writeFloat('[PlayerCoordinates]+84', 952.4784546)
writeFloat('[PlayerCoordinates]+88', 99.27870941)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134093
"Edge Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -624.60943603516)
writeFloat('[PlayerCoordinates]+84', 156.75914001465)
writeFloat('[PlayerCoordinates]+88', 99.559226989746)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134094
"Vehicle"
1
134095
"Eastern Region"
1
134096
"Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1442.88495919048) --X1
writeDouble('[VehicleCoordinates]+8F8', 1442.88495919048) --X2
writeDouble('[VehicleCoordinates]+D0', 690.599788112928) --Y1
writeDouble('[VehicleCoordinates]+900', 690.599788112928) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.302408912237) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.302408912237) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134097
"Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134098
"Incinerator West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 547.585388183594) --X1
writeDouble('[VehicleCoordinates]+8F8', 547.585388183594) --X2
writeDouble('[VehicleCoordinates]+D0', 361.8267997735) --Y1
writeDouble('[VehicleCoordinates]+900', 361.8267997735) -- Y2
writeDouble('[VehicleCoordinates]+D8', 236.925926215194) -- Z1
writeDouble('[VehicleCoordinates]+908', 236.925926215194) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134099
"Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 92.6874055161516) --X1
writeDouble('[VehicleCoordinates]+8F8', 92.6874055161516) --X2
writeDouble('[VehicleCoordinates]+D0', 540.118915277497) --Y1
writeDouble('[VehicleCoordinates]+900', 540.118915277497) -- Y2
writeDouble('[VehicleCoordinates]+D8', 206.047497367006) -- Z1
writeDouble('[VehicleCoordinates]+908', 206.047497367006) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134100
"Musician"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -981.190973857123) --X1
writeDouble('[VehicleCoordinates]+8F8', -981.190973857123) --X2
writeDouble('[VehicleCoordinates]+D0', -112.683721600795) --Y1
writeDouble('[VehicleCoordinates]+900', -112.683721600795) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.940941071383) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.940941071383) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134101
"Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134102
"Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134103
"Wind Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1486.93542206135) --X1
writeDouble('[VehicleCoordinates]+8F8', -1486.93542206135) --X2
writeDouble('[VehicleCoordinates]+D0', 652.813289342022) --Y1
writeDouble('[VehicleCoordinates]+900', 652.813289342022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 204.475858193206) -- Z1
writeDouble('[VehicleCoordinates]+908', 204.475858193206) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134104
"Central Region"
1
134105
"Aaron Hill's Safe House"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2632.01806640625) --X1
writeDouble('[VehicleCoordinates]+8F8', -2632.01806640625) --X2
writeDouble('[VehicleCoordinates]+D0', -2038.36877441406) --Y1
writeDouble('[VehicleCoordinates]+900', -2038.36877441406) -- Y2
writeDouble('[VehicleCoordinates]+D8', 85.2701416015625) -- Z1
writeDouble('[VehicleCoordinates]+908', 85.2701416015625) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134106
"Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134107
"Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134108
"Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134109
"Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134110
"Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134111
"Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134112
"Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134113
"Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136398
"Engineer"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2177.6196289063) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2178.78515625) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1188.1011962891) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1188.3251953125) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',176.92051696777) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',176.92469787598) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134115
"Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134116
"Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134117
"First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134118
"Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134119
"Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134120
"Incinerator West of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -322.187921711329) --X1
writeDouble('[VehicleCoordinates]+8F8', -322.187921711329) --X2
writeDouble('[VehicleCoordinates]+D0', 2190.62475585938) --Y1
writeDouble('[VehicleCoordinates]+900', 2190.62475585938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 217.562371936685) -- Z1
writeDouble('[VehicleCoordinates]+908', 217.562371936685) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134121
"Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134122
"Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134123
"Mama's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1013.66293989933) --X1
writeDouble('[VehicleCoordinates]+8F8', 1013.66293989933) --X2
writeDouble('[VehicleCoordinates]+D0', -973.060315833813) --Y1
writeDouble('[VehicleCoordinates]+900', -973.060315833813) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.76572519014) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.76572519014) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134124
"Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134125
"Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134126
"Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2429.98510742188) --X1
writeDouble('[VehicleCoordinates]+8F8', -2429.98510742188) --X2
writeDouble('[VehicleCoordinates]+D0', 1292.8735588775) --Y1
writeDouble('[VehicleCoordinates]+900', 1292.8735588775) -- Y2
writeDouble('[VehicleCoordinates]+D8', 249.609417378204) -- Z1
writeDouble('[VehicleCoordinates]+908', 249.609417378204) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134127
"Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134128
"Peter Englert"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1736.88663510808) --X1
writeDouble('[VehicleCoordinates]+8F8', 1736.88663510808) --X2
writeDouble('[VehicleCoordinates]+D0', 1964.92318763108) --Y1
writeDouble('[VehicleCoordinates]+900', 1964.92318763108) -- Y2
writeDouble('[VehicleCoordinates]+D8', 210.988873047901) -- Z1
writeDouble('[VehicleCoordinates]+908', 210.988873047901) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134129
"Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134130
"Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134131
"Racetrack Terminal"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',127.4136524018) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',127.4136524018) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1989.1642396448) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1989.1642396448) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',98.7200925845) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',98.7200925845) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134132
"Ruined Shelter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1321.75479916266) --X1
writeDouble('[VehicleCoordinates]+8F8', 1321.75479916266) --X2
writeDouble('[VehicleCoordinates]+D0', 1781.333984375) --Y1
writeDouble('[VehicleCoordinates]+900', 1781.333984375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 199.04028204791) -- Z1
writeDouble('[VehicleCoordinates]+908', 199.04028204791) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134133
"South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134134
"Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134135
"Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134136
"UCA-41-011: Chiral Relay (Potential Chiral Relay Construction Site)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2560.48546139061) --X1
writeDouble('[VehicleCoordinates]+8F8', -2560.48546139061) --X2
writeDouble('[VehicleCoordinates]+D0', -1977.87025744527) --Y1
writeDouble('[VehicleCoordinates]+900', -1977.87025744527) -- Y2
writeDouble('[VehicleCoordinates]+D8', 84.1606949204215) -- Z1
writeDouble('[VehicleCoordinates]+908', 84.1606949204215) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134137
"Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134138
"Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134139
"Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134140
"Episode Quests"
1
134141
"Player"
1
134142
"Episode 0 - Porter (Prologue)"
1
134143
"Order 1 - Item 1/4 is already in your backpack"
1
134145
"Order 1 - Item 2/4 (start position of game)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 271.0780029)
writeFloat('[PlayerCoordinates]+84', 100.2480087)
writeFloat('[PlayerCoordinates]+88', 194.905899)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134144
"Order 1 - Find Shelter From the Rain"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',199.7405090332) -- X Coord
writeFloat('[PlayerCoordinates]+84',167.70687866211) -- Y Coord
writeFloat('[PlayerCoordinates]+88',187.07148742676) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136490
"Order 1 - Song 1: Low Roar - Don't Be So Serious (Head towards waypoint after shelter scene)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',179.20838928223) -- X Coord
writeFloat('[PlayerCoordinates]+84',170.82894897461) -- Y Coord
writeFloat('[PlayerCoordinates]+88',187.83499145508) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134146
"Order 1 - Item 3/4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 81.33251953)
writeFloat('[PlayerCoordinates]+84', 101.0986786)
writeFloat('[PlayerCoordinates]+88', 140.3443604)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134147
"Order 1 - Item 4/4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -74.51483917)
writeFloat('[PlayerCoordinates]+84', -159.1582489)
writeFloat('[PlayerCoordinates]+88', 128.949173)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134148
"Order 1 - Deliver to Central Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -128.5132141)
writeFloat('[PlayerCoordinates]+84', -330.1140137)
writeFloat('[PlayerCoordinates]+88', 132.0313263)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134149
"This takes you to Episode 1: Bridget"
1
134150
"Episode 1: Bridget"
1
134151
"Order 2 - Pick up the Morphine"
1
136383
"Order 2 - Codec conversation with Die-Hardman ahead"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1444.9926757813) -- X Coord
writeFloat('[PlayerCoordinates]+84',759.36846923828) -- Y Coord
writeFloat('[PlayerCoordinates]+88',148.23420715332) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134152
"Order 2 - Deliver to Central Knot City Isolation Ward"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1691.9838867188) -- X Coord
writeFloat('[PlayerCoordinates]+84',1050.6905517578) -- Y Coord
writeFloat('[PlayerCoordinates]+88',136.55059814453) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136491
"Order 3 Part 1 - Song 2: Low Roar - Bones (Head towards waypoint)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1204.1784667969) -- X Coord
writeFloat('[PlayerCoordinates]+84',812.31652832031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',140.87066650391) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134153
"Order 3 Part 1 - Cremate President's Body at Incinerator West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 526.8500977)
writeFloat('[PlayerCoordinates]+84', 330.2707825)
writeFloat('[PlayerCoordinates]+88', 238.345871)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136384
"Order 3 Part 2 - Song 3: Low Roar - Poznan (Head towards waypoint)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',929.37469482422) -- X Coord
writeFloat('[PlayerCoordinates]+84',618.68731689453) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.69285583496) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134154
"Order 3 Part 2 - Return to the Capital Knot Distribution Center Terminal"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1438.978394)
writeFloat('[PlayerCoordinates]+84', 780.0618896)
writeFloat('[PlayerCoordinates]+88', 148.1144562)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134155
"This takes you to Episode 2: Amelie"
1
134156
"Episode 2: Amelie"
1
134157
"Order 4 - Accept Order 4 from Capitol Knot City"
1
134158
"Order 4 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134159
"Accept Order 5 & 6 from Waystation West of Capital Knot City"
1
134160
"Order 6 - Build Construction: Postbox - Northeast of Waystation West of Capital Knot City "
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 588.8013306)
writeFloat('[PlayerCoordinates]+84', 1223.86792)
writeFloat('[PlayerCoordinates]+88', 139.7748566)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134161
"Order 5 Part 1 - Exit Mule Camp Cutscene [if MULEs not chasing, no cutscene]"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 19.9727993)
writeFloat('[PlayerCoordinates]+84', 855.8658447)
writeFloat('[PlayerCoordinates]+88', 137.9019165)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134162
"Order 5 Part 2 - BB Cutscene [move forward until cutscene]"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -375.3905029)
writeFloat('[PlayerCoordinates]+84', 617.4586792)
writeFloat('[PlayerCoordinates]+88', 146.4345398)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134163
"Order 5 Part 3 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -439.4762878)
writeFloat('[PlayerCoordinates]+84', 264.5787659)
writeFloat('[PlayerCoordinates]+88', 137.3742676)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134164
"Head to Private Room, then Accept Order 7 & 8"
1
134165
"Order 7 - Retrieve item from MULEs postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -623.3140869)
writeFloat('[PlayerCoordinates]+84', -106.4582138)
writeFloat('[PlayerCoordinates]+88', 223.6954346)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134166
"Order 8 - Collect at least 1cg of chiral crystals"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -329.8672485)
writeFloat('[PlayerCoordinates]+84', 424.4443359)
writeFloat('[PlayerCoordinates]+88', 145.6047974)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134167
"Order 7 & 8 - Deliver & Recycle at Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -439.3278198)
writeFloat('[PlayerCoordinates]+84', 264.6150818)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134168
"Accept Order 9 & 10 & 77 (Director's Cut Episode Quest)"
1
134169
"Order 10 - Build a Bridge West of Distribution Center "
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -509.8740234)
writeFloat('[PlayerCoordinates]+84', 333.1643066)
writeFloat('[PlayerCoordinates]+88', 149.1089172)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134170
"Order 9 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134508
"Accept Order 77 from Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134509
"Order 77 - Outside Entrance of Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',120.52124786377) -- X Coord
writeFloat('[PlayerCoordinates]+84',452.49322509766) -- Y Coord
writeFloat('[PlayerCoordinates]+88',252.72410583496) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134510
"Note: I had to do standard missions from this location to get Order 77 to unlock in late-game"
1
134511
"Order 77 - Pick up item 4 items at Ruined Factory MULEs Postbox"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',277.41485595703) -- X Coord
writeFloat('[PlayerCoordinates]+84',519.83526611328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136492
"Order 77 - Song 4: Woodkid - Pale Yellow (head northwest towards wp)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',120.52124786377) -- X Coord
writeFloat('[PlayerCoordinates]+84',452.49322509766) -- Y Coord
writeFloat('[PlayerCoordinates]+88',252.72410583496) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134512
"Order 77 - Deliver to Distribution Center West of Capital Knot City & Accept Order 78"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136493
"Order 78 - Open Control Panel #1 at Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',277.41485595703) -- X Coord
writeFloat('[PlayerCoordinates]+84',519.83526611328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136497
"Order 78 - Song 5: Woodkid - Goliath"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-379.37738037109) -- X Coord
writeFloat('[PlayerCoordinates]+84',360.06365966797) -- Y Coord
writeFloat('[PlayerCoordinates]+88',147.15422058105) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136494
"Order 78 - Pick up 5 item from MULEs Postbox"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',341.39114379883) -- X Coord
writeFloat('[PlayerCoordinates]+84',517.20544433594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136495
"Order 78 - Teleport back to Vehicle (if you used it)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',241.1863861084) -- X Coord
writeFloat('[PlayerCoordinates]+84',539.00946044922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',307.48614501953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136496
"Order 78 - Deliver to Distribution Center West of Capital Knot City & Accept Order 79"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136498
"Accept Order 11 - From Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136499
"Order 11 - Song 6: Low Roar - Anything You Need (head southeast)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1100.0772705078) -- X Coord
writeFloat('[PlayerCoordinates]+84',472.79187011719) -- Y Coord
writeFloat('[PlayerCoordinates]+88',271.25128173828) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134172
"Head down hill towards Distribution Center to receive email "“How About Taking a Break In a Private Room?”"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-703.07580566406) -- X Coord
writeFloat('[PlayerCoordinates]+84',333.38226318359) -- Y Coord
writeFloat('[PlayerCoordinates]+88',153.00730895996) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134173
"Order 11 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -439.3278198)
writeFloat('[PlayerCoordinates]+84', 264.6150818)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134174
"Go to Private Room after turning in Order 11 then read your email: "[Test Order] I Want You to Look for Some Lost Cargo""
1
134175
"Build a Generator for Access to Bike outside Distribution Center at this Location"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-402.11831665039) -- X Coord
writeFloat('[PlayerCoordinates]+84',353.53024291992) -- Y Coord
writeFloat('[PlayerCoordinates]+88',147.03295898438) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134176
"Collect Lost Cargo: Companion Cube: Benjamin (Cube 1)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -223.7529602)
writeFloat('[PlayerCoordinates]+84', 469.90802)
writeFloat('[PlayerCoordinates]+88', 146.6058655)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134177
"Deliver Lost Cargo: Companion Cube: Benjamin to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -439.3278198)
writeFloat('[PlayerCoordinates]+84', 264.6150818)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134178
"Accept Order 12 & 13 From Distribution Center West of Capital Knot City"
1
134179
"Order 12 - Pick up item from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 348.9523926)
writeFloat('[PlayerCoordinates]+84', 806.6796265)
writeFloat('[PlayerCoordinates]+88', 164.618454)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134180
"Order 12 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 304.9683533)
writeFloat('[PlayerCoordinates]+84', 1157.673462)
writeFloat('[PlayerCoordinates]+88', 162.9699249)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136500
"Order 13 - Song 7: Low Roar - Easy Way Out (head east)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',545.21099853516) -- X Coord
writeFloat('[PlayerCoordinates]+84',1088.7515869141) -- Y Coord
writeFloat('[PlayerCoordinates]+88',139.13175964355) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134181
"Order 13 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134182
"Accept Order 14 which gives you Hematic Grenades, then Accept Order 15 From Capital Knot City"
1
134183
"Order 15 Part 1 - Go to the BT Area / Defeat a BT With Hematic Grenades / Collect Chiral Crystals"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 953.0679321)
writeFloat('[PlayerCoordinates]+84', 1085.765625)
writeFloat('[PlayerCoordinates]+88', 136.118988)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134184
"Order 15 Part 2 - Recycle Chiral Crystals at Distribution Center West of Capital Knot City "
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136502
"Order 14 - Song 8: Silent Poets - Asylums for the Feeling (head west)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1472.8107910156) -- X Coord
writeFloat('[PlayerCoordinates]+84',-7.5769810676575) -- Y Coord
writeFloat('[PlayerCoordinates]+88',313.52935791016) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134185
"Order 14 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134186
"Head out of Port Knot City - First Boss Battle (BT#1)"
1
134187
"Order 16 - Eliminate BT"
1
134188
"Head Back to Port Knot City to Grab Bike (if desired)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134189
"Note: You need Ludens Fan to join UCA to receive Order 17, do standard missions / lost cargo before starting Episode 3"
1
134190
"Head for the Harbor - move forward for codec cutscene"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1976.712646)
writeFloat('[PlayerCoordinates]+84', -690.2081299)
writeFloat('[PlayerCoordinates]+88', 148.8500061)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134191
"Head to Episode 3: Fragile / Central Region"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1978.044312)
writeFloat('[PlayerCoordinates]+84', -741.3048706)
writeFloat('[PlayerCoordinates]+88', 148.8501892)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134192
"Episode 3: Fragile"
1
134193
"Order 18 - Pick up your three containers of aid"
1
136503
"Order 18 - Song 9: Low Roar - Patience (walk up stairs that exit the dock)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2610.7316894531) -- X Coord
writeFloat('[PlayerCoordinates]+84',1694.2489013672) -- Y Coord
writeFloat('[PlayerCoordinates]+88',192.34963989258) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134194
"Order 18 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134195
"Read The Ludens Fan e-mail: "Delivery to Port Knot City" (Requires Ludens Fan having joined UCA)"
1
134196
"Use Fragile Jump in Private Room to go back to Port Knot City"
1
134197
"Head to Ludens Fan for Order 17"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 101.4508591)
writeFloat('[PlayerCoordinates]+84', 539.0170288)
writeFloat('[PlayerCoordinates]+88', 207.0962372)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134198
"Order 17 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134199
"Use private room & Fragile Jump to go back to Lake Knot City"
1
134200
"Accept Order 19, 20, 21 from Lake Knot City"
1
134201
"Order 19 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134202
"Order 20 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134203
"Order 21 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134204
"Accept Order 22 from Craftsman"
1
134205
"Order 22 Part 1 - Recover the toolbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1330.974731)
writeFloat('[PlayerCoordinates]+84', 1794.068848)
writeFloat('[PlayerCoordinates]+88', 199.2028198)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134206
"Order 22 Part 2 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134207
"Exit Craftsman for codec cutscene that gives you Order 23"
1
134208
"Order 23 - Retrieve item from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.555176)
writeFloat('[PlayerCoordinates]+84', 1064.6875)
writeFloat('[PlayerCoordinates]+88', 176.1872711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134209
"Order 23 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134210
"Accept Order 25 from Lake Knot City"
1
134211
"Order 25 - Reconstruct the road at the Auto Paver South of Lake Knot City "
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2453.14624)
writeFloat('[PlayerCoordinates]+84', 1699.640625)
writeFloat('[PlayerCoordinates]+88', 211.4180145)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134212
"Head back to Lake Knot City to Accept Order 24, 26"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134213
"Order 26 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1749.9689941406)
writeFloat('[PlayerCoordinates]+84', 1971.5640869141)
writeFloat('[PlayerCoordinates]+88', 211.4801940918)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134214
"read email from William L: [Test Order] Find my Lost Cargo, Please!”"
1
134215
"Pick up "Lost Cargo: Companion Cube: William" (Cube 2)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1752.894043)
writeFloat('[PlayerCoordinates]+84', 1982.041016)
writeFloat('[PlayerCoordinates]+88', 211.5847626)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134216
"Deliver "Lost Cargo: Companion Cube: William" to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136504
"Order 24 - Song 10: Low Roar - Breath In (head southwest towards waypoint)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2081.4807128906) -- X Coord
writeFloat('[PlayerCoordinates]+84',1081.4243164063) -- Y Coord
writeFloat('[PlayerCoordinates]+88',180.41471862793) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134217
"Order 24 - Deliver to Distribution Center South of Lake Knot City "
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134218
"read email from Thomas Southerland [Recovery Request] [V] Track Down a Chip with a Weird Symbol"
1
134219
"Accept Order 71 from Distribution Center South of Lake Knot City"
1
134220
"Order 71 Part 1 - Pick up Item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1112.9328613281) -- X Coord
writeFloat('[PlayerCoordinates]+84',160.90766906738) -- Y Coord
writeFloat('[PlayerCoordinates]+88',137.19442749023) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134221
"Order 71 Part 2 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134222
"Accept Order 27 from Distribution Center South of Lake Knot City"
1
134223
"Order 27 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134224
"Accept Order 29 from Weather Station"
1
134225
"Order 29 - Build & Upgrade a Safe House near Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 112.3721466)
writeFloat('[PlayerCoordinates]+84', -306.8156738)
writeFloat('[PlayerCoordinates]+88', 268.5441284)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134226
"Enter Private Room"
1
136390
"Accept Order 80 from Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136391
"Order 80 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134227
"Head back to Weather Station to Accept Order 28"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136392
"Order 28 - Song 11: Low Roar - I'm Leaving (Head South)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',100.38347625732) -- X Coord
writeFloat('[PlayerCoordinates]+84',-567.69995117188) -- Y Coord
writeFloat('[PlayerCoordinates]+88',213.74189758301) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134228
"Order 28 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136505
"After Completing order 28: Song 12: Low Roar - Gosia"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',836.28149414063) -- X Coord
writeFloat('[PlayerCoordinates]+84',-25.667373657227) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.85478210449) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134229
"Head to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134230
"Read email from Thomas Southerland [Test Order] You've Got to Find my Cube!"
1
134231
"Pick up "Lost Cargo: Companion Cube: Thomas (Cube 3) in Mule Camp"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 580.3560181)
writeFloat('[PlayerCoordinates]+84', 902.6835327)
writeFloat('[PlayerCoordinates]+88', 169.22052)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134232
"Deliver Lost Cargo to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134233
"Accept Order 30, 31 from Distribution Center South of Lake Knot City"
1
134234
"Order 31 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134235
"Order 30 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134236
"Accept Order 32 from Junk Dealer"
1
134237
"Order 32 Part 1 - Item 1/7 (10kg/110kg)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1280.342285)
writeFloat('[PlayerCoordinates]+84', -740.7521973)
writeFloat('[PlayerCoordinates]+88', 142.1518402)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134238
"Order 32 Part 1 - Item 2/7 (20kg/110kg)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1243.190796)
writeFloat('[PlayerCoordinates]+84', -679.7549438)
writeFloat('[PlayerCoordinates]+88', 144.0487366)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134239
"Order 32 Part 1 - Item 3/7 (10kg/110kg)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1214.950439)
writeFloat('[PlayerCoordinates]+84', -619.7698975)
writeFloat('[PlayerCoordinates]+88', 139.3390656)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134240
"Order 32 Part 1 - Item 4/7 (10kg/110kg)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1233.258667)
writeFloat('[PlayerCoordinates]+84', -609.4537964)
writeFloat('[PlayerCoordinates]+88', 138.0766602)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134241
"Order 32 Part 1 - Item 5/7 (30kg/110kg)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1172.618286)
writeFloat('[PlayerCoordinates]+84', -578.3938599)
writeFloat('[PlayerCoordinates]+88', 142.9857941)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134242
"Order 32 Part 1 - Item 6/7 (10kg/110kg)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1189.529175)
writeFloat('[PlayerCoordinates]+84', -652.6791992)
writeFloat('[PlayerCoordinates]+88', 141.5029602)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134243
"Order 32 Part 1 - Item 7/7 (20kg/110kg)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1212.683716)
writeFloat('[PlayerCoordinates]+84', -657.9247437)
writeFloat('[PlayerCoordinates]+88', 144.5106659)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134244
"Order 32 Part 2 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134245
"Accept Order 33 from Junk Dealer"
1
134246
"Order 33 - Deliver to Chiral Artist (carry by hand/no vehicle allowed)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136393
"Accept Order 81 from Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136394
"Order 81 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136395
"Head back to Chiral Artist and accept Order 34"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134247
"Order 34 doesn't allow cargo bag, turn in any lost cargo you have before accepting or drop them"
1
136396
"Order 34 - Song 13: Low Roar - Give Up (Move North)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1919.9466552734) -- X Coord
writeFloat('[PlayerCoordinates]+84',-810.05206298828) -- Y Coord
writeFloat('[PlayerCoordinates]+88',128.09399414063) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134248
"Order 34 - Reunite Junk Dealer with Chiral Artist (Carrying Live Body)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134249
"Accept Order 35 from Junk Dealer"
1
134250
"Order 35 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134251
"Read email: "[Order] Delivery for a Prepper""
1
134252
"Accept Order 36, 37 from Distribution Center South of Lake Knot City"
1
134253
"Order 37 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134254
"Order 36 Part 1 - Recover items 1-3 from MULEs, (MULEs move around - this is original locations)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1381.5128173828) -- X Coord
writeFloat('[PlayerCoordinates]+84',151.97709655762) -- Y Coord
writeFloat('[PlayerCoordinates]+88',134.24496459961) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134255
"Order 36 Part 1 - Recover items 4-6 from MULEs (MULEs move around - this is original locations)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1431.1962890625) -- X Coord
writeFloat('[PlayerCoordinates]+84',208.53698730469) -- Y Coord
writeFloat('[PlayerCoordinates]+88',134.59356689453) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136397
"Order 36 - Part 2 Song 14: Low Roar - Waiting (10 Years) (Head Northeast)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1566.4313964844) -- X Coord
writeFloat('[PlayerCoordinates]+84',1352.9691162109) -- Y Coord
writeFloat('[PlayerCoordinates]+88',176.20359802246) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134256
"Order 36 Part 2 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134257
"***Don't Accept Order 38 Yet***"
0000FF
1
134258
"Go to Private Room at Lake Knot City"
1
134259
"Read email from J: [Recovery Request] [V] Retrieve My Chip from the MULEs, Take Order 72"
1
134260
"Read email from T Southerland [Test Order] Sorry. More Lost Cargo for You..."
1
134261
"Accept Order 72 from Lake Knot City"
1
134262
"Order 72 - Retrieve V's chip from the MULEs"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2464.028809)
writeFloat('[PlayerCoordinates]+84', 1354.382446)
writeFloat('[PlayerCoordinates]+88', 186.3952332)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134263
"Pick up "Lost Cargo: Companion Cube: Southerland" (Cube 4)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 631.1247559)
writeFloat('[PlayerCoordinates]+84', 1512.86377)
writeFloat('[PlayerCoordinates]+88', 172.6147614)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134264
"Deliver Lost Cargo (Cube 4) to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134265
"Order 72 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134266
"Turn in any Lost Cargo beforehand then Accept Order 38 from Lake Knot City"
1
134267
"Order 38 - Head to private room to talk to Fragile at Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136412
"Order 38 - Dispose of the Nuclear Bomb in a Crater Lake [Don't Do it on West Side if you want the song]"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1677.5826416016) -- X Coord
writeFloat('[PlayerCoordinates]+84',-745.86187744141) -- Y Coord
writeFloat('[PlayerCoordinates]+88',130.33343505859) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136413
"Order 38 - Walk West for Song 15: Low Roar - Without You"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1570.7454833984) -- X Coord
writeFloat('[PlayerCoordinates]+84',-689.51049804688) -- Y Coord
writeFloat('[PlayerCoordinates]+88',130.8695526123) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134269
"Order 38 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134270
"Walk back up the ramp to move to Episode 4: Unger"
1
134271
"Episode 4: Unger"
1
134272
"Order 39 Part 1 - [World War I] Escape the Battlefield"
1
134273
"Items - Hematic Grenades (Lvl 1)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-5.9417910575867) -- X Coord
writeFloat('[PlayerCoordinates]+84',263.12982177734) -- Y Coord
writeFloat('[PlayerCoordinates]+88',91.064674377441) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134274
"Items - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',7.6940546035767) -- X Coord
writeFloat('[PlayerCoordinates]+84',227.98132324219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',91.315788269043) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134275
"Items - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 21.54985428)
writeFloat('[PlayerCoordinates]+84', 208.2553101)
writeFloat('[PlayerCoordinates]+88', 91.9463501)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134276
"Items - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 64.79664612)
writeFloat('[PlayerCoordinates]+84', 158.5385895)
writeFloat('[PlayerCoordinates]+88', 96.92805481)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134277
" Move South and use Odradek Scanner until it locates the blood bag if you want the last one to spawn before going forward"
1
134278
"Items - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 74.96125031)
writeFloat('[PlayerCoordinates]+84', 105.9614334)
writeFloat('[PlayerCoordinates]+88', 101.1288147)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134279
"Items - Blood Bag & move forward (south into doorway) to begin Part2"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',49.464370727539) -- X Coord
writeFloat('[PlayerCoordinates]+84',20.651393890381) -- Y Coord
writeFloat('[PlayerCoordinates]+88',93.932151794434) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134280
"Order 39 Part 2 - [World War I] Find the Mysterious Man (First Cliff Unger Boss Battle)"
1
134281
"Items - Assault Rifle (Lvl 1)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 20.87845802)
writeFloat('[PlayerCoordinates]+84', -7.217926979)
writeFloat('[PlayerCoordinates]+88', 90.74695587)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134282
"Items - Blood Bag"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 15.76558113)
writeFloat('[PlayerCoordinates]+84', -23.46003532)
writeFloat('[PlayerCoordinates]+88', 89.58705902)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134283
"Items - Shotgun (Lvl 1)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 35.02058792)
writeFloat('[PlayerCoordinates]+84', -46.3934288)
writeFloat('[PlayerCoordinates]+88', 88.71324158)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134284
"Items - Grenades"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1.812289357)
writeFloat('[PlayerCoordinates]+84', -32.2932663)
writeFloat('[PlayerCoordinates]+88', 90.08486176)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134285
"Minifight 1"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 10.41056061)
writeFloat('[PlayerCoordinates]+84', -75.96162415)
writeFloat('[PlayerCoordinates]+88', 87.30445862)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134286
"Minifight 2, 3, & 4 are random locations, follow the fire trail"
0000FF
1
134287
"Items - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -34.02104568)
writeFloat('[PlayerCoordinates]+84', -34.71165848)
writeFloat('[PlayerCoordinates]+88', 87.24714661)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134288
"Items - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 12.78002453)
writeFloat('[PlayerCoordinates]+84', -22.13700485)
writeFloat('[PlayerCoordinates]+88', 89.77045441)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134289
"Items - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 104.524826)
writeFloat('[PlayerCoordinates]+84', -134.4927368)
writeFloat('[PlayerCoordinates]+88', 88.16183472)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134290
"Items - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2.931415796)
writeFloat('[PlayerCoordinates]+84', -98.74702454)
writeFloat('[PlayerCoordinates]+88', 87.87839508)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134291
"Back in Central Region,pick up your loot and read Peter Englert's email: "A Desperate Plea for a Second Pizza Pie""
1
134292
"Go to South Knot City terminal and Accept Order 40"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134293
"Order 40 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1749.9689941406)
writeFloat('[PlayerCoordinates]+84', 1971.5640869141)
writeFloat('[PlayerCoordinates]+88', 211.4801940918)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134294
"Head to Mama's Lab to begin Episode 5: Mama & Initiate Cutscene"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1012.746277)
writeFloat('[PlayerCoordinates]+84', -973.0059204)
writeFloat('[PlayerCoordinates]+88', 162.7924652)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134295
"Episode 5: Mama"
1
134296
"read email: "[Recovery Request] Resources Scattered by the SuperCell""
1
134297
"Use Mama's Lab Terminal to Accept Order 42"
1
134298
"Order 42 Part 1 - Item 1/4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 600.565918)
writeFloat('[PlayerCoordinates]+84', -777.9202881)
writeFloat('[PlayerCoordinates]+88', 83.43596649)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134299
"Order 42 Part 1 - Item 2/4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 519.2785034)
writeFloat('[PlayerCoordinates]+84', -819.0073853)
writeFloat('[PlayerCoordinates]+88', 83.33805847)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134300
"Order 42 Part 1 - Item 3/4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 464.8079224)
writeFloat('[PlayerCoordinates]+84', -816.6542358)
writeFloat('[PlayerCoordinates]+88', 100.8517303)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134301
"Order 42 Part 1 - Item 4/4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 468.8051147)
writeFloat('[PlayerCoordinates]+84', -856.4064331)
writeFloat('[PlayerCoordinates]+88', 101.3171005)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134302
"Order 42 Part 2 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134303
"Head to Distribution Center South of Lake Knot City to Accept Order 83, then 41"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136414
"Accept Order 83 from Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136415
"Order 83 - Near Rescue Area (Conversation/cutscene moving southeast, near the water)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2123.7663574219) -- X Coord
writeFloat('[PlayerCoordinates]+84',-697.38775634766) -- Y Coord
writeFloat('[PlayerCoordinates]+88',185.66040039063) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136417
"Order 83: Song 16: Biting Elbows - Control (Head North)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2013.0843505859) -- X Coord
writeFloat('[PlayerCoordinates]+84',-873.80017089844) -- Y Coord
writeFloat('[PlayerCoordinates]+88',128.18559265137) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136416
"Order 83 - Deliver to Distribution Center South of Lake Knot City then accept Order 41"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136418
"Order 41: Song 17: Low Roar - Breathe In"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',489.46475219727) -- X Coord
writeFloat('[PlayerCoordinates]+84',1150.1977539063) -- Y Coord
writeFloat('[PlayerCoordinates]+88',251.46676635742) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134304
"Order 41: Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134305
"Accept Order 43 from Waystation North of Mountain Knot City"
1
134306
"Order 43 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134307
"read email: "[Recovery Request][X] I've Lost Contact wit the Porter Who Recovered my Chip""
1
134308
"Accept Order 73 from Distribution Center North of Mountain Knot City, Don't Accept Order 44"
1
134309
"Order 73 Part 1 - Pick up Item"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -803.5339355)
writeFloat('[PlayerCoordinates]+84', 2032.589111)
writeFloat('[PlayerCoordinates]+88', 280.0082703)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134310
"Order 73 Part 2 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134311
"turn in any lost cargo & deposit backpack / you move a body"
1
134312
"Order 73 Part 3 - Pick Up the Body"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -825.8656616)
writeFloat('[PlayerCoordinates]+84', 2038.21814)
writeFloat('[PlayerCoordinates]+88', 287.9641418)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134313
"Order 73 Part 4 - Cremate the Body at Incinerator West of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -322.81805419922)
writeFloat('[PlayerCoordinates]+84', 2191.2136230469)
writeFloat('[PlayerCoordinates]+88', 218.59948730469)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134314
"Turn In Order 73 and Accept Order 44 at the Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136421
"Order 44 - Song 18: Low Roar - Because We Have To (walk east up the mountain)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1305.7592773438) -- X Coord
writeFloat('[PlayerCoordinates]+84',701.68048095703) -- Y Coord
writeFloat('[PlayerCoordinates]+88',357.314453125) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134315
"Order 44 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136422
"Change Lockne's Mind (in between Order 44 and 45) Song 19: Low Roar - Once In A Long, Long While..."
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-152.96266174316) -- X Coord
writeFloat('[PlayerCoordinates]+84',259.77966308594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',461.22006225586) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134316
"read email: "Yet Another Easnest Entreaty for Pizza""
1
134317
"Head to Timefall Farm to Accept Order 45 - Fresh Pizza Delivery"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134318
"Order 45 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1749.9689941406)
writeFloat('[PlayerCoordinates]+84', 1971.5640869141)
writeFloat('[PlayerCoordinates]+88', 211.4801940918)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134319
"Head to Mama's Lab to be given Order 46 to change Lockne's Mind"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1012.746277)
writeFloat('[PlayerCoordinates]+84', -973.0059204)
writeFloat('[PlayerCoordinates]+88', 162.7924652)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134320
"Exit Mama's Lab for Second BT Boss Battle (BT#2)"
0000FF
1
134321
"Pick Mama back up if you dropped her"
1
136424
"Order 46 - Song 20: Low Roar - The Machine (North up mountain)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-328.55981445313) -- X Coord
writeFloat('[PlayerCoordinates]+84',-390.75988769531) -- Y Coord
writeFloat('[PlayerCoordinates]+88',394.70080566406) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134322
"Order 46 - Take Mama to Meet Lockne at Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134323
"This takes you to Episode 6: Deadman"
1
134324
"Episode 6: Deadman"
1
134325
"read email: "[Recovery Request][V] The Porter Had Not One, but Two Chips""
1
136319
"Order 74 - Head farther out for a codec cutscene"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1157.564941)
writeFloat('[PlayerCoordinates]+84', 282.0364685)
writeFloat('[PlayerCoordinates]+88', 364.2423706)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134326
"Accept Order 74 at Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134327
"Order 74 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -758.4589233)
writeFloat('[PlayerCoordinates]+84', 1811.8302)
writeFloat('[PlayerCoordinates]+88', 224.3075867)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134328
"Order 74 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134329
"Accept Order 84 from Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136426
"Order 84 - Head east to rescue porter"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-879.98309326172) -- X Coord
writeFloat('[PlayerCoordinates]+84',454.32437133789) -- Y Coord
writeFloat('[PlayerCoordinates]+88',466.90200805664) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136427
"Order 84 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136428
"Accept Order 47 & 48 from Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136430
"Order 47 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136431
"Order 48 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134333
"Head Back to Mountain Knot City to Accept Order 49"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134334
"Order 49 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134335
"Accept Order 50 from Mountaineer"
1
134336
"Order 50 Part 1 - Pick up 2 items from Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134337
"Order 50 Part 2 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134338
"Accept Order 51 from Mountaineer"
1
136435
"Order 51 - Song 21: Low Roar - Rolling Over (head west)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1185.8981933594) -- X Coord
writeFloat('[PlayerCoordinates]+84',905.60626220703) -- Y Coord
writeFloat('[PlayerCoordinates]+88',487.51434326172) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134339
"Order 51 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134340
"Accept Order 52 from Photographer"
1
134341
"Order 52 Part 1 - Recover Camera in Mule Camp from MULE"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1686.0187988281) -- X Coord
writeFloat('[PlayerCoordinates]+84',1073.8552246094) -- Y Coord
writeFloat('[PlayerCoordinates]+88',220.45040893555) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136436
"Order 52 Part 1 - Song 22: Low Roar - St. Eriksplan (head south)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2066.9291992188) -- X Coord
writeFloat('[PlayerCoordinates]+84',1030.4417724609) -- Y Coord
writeFloat('[PlayerCoordinates]+88',216.70544433594) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134342
"Order 52 Part 2 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136440
"Order 85 - Head to to Distribution Center North of Mountain Knot City and accept Order 85"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136438
"Order 85 - Head south (up hill) to rescue porter+cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2131.6853027344) -- X Coord
writeFloat('[PlayerCoordinates]+84',-302.28720092773) -- Y Coord
writeFloat('[PlayerCoordinates]+88',522.76147460938) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136442
"Order 85 - Song 23: Biting Elbows - Other Me (head north)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2112.9208984375) -- X Coord
writeFloat('[PlayerCoordinates]+84',-119.00605010986) -- Y Coord
writeFloat('[PlayerCoordinates]+88',530.82916259766) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136439
"Order 85 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134343
"Head to Mountaineer to Accept Order 53"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134344
"Order 53 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136443
"Accept Order 82 from Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136444
"Order 82 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134345
"Meet up with Deadman at the Cabin near Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -488.2041321)
writeFloat('[PlayerCoordinates]+84', 511.7808533)
writeFloat('[PlayerCoordinates]+88', 681.1845093)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134346
"This takes you to Episode 7: Clifford"
1
134347
"Episode 7: Clifford"
1
134348
"Items"
1
134349
"Order 54 Part 1 - Anti-BT Handgun (Lvl 1) [may not exist]"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',171.32550048828) -- X Coord
writeFloat('[PlayerCoordinates]+84',171.54541015625) -- Y Coord
writeFloat('[PlayerCoordinates]+88',106.21268463135) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134350
"Order 54 Part 1 - Cryptobiote"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',161.54278564453) -- X Coord
writeFloat('[PlayerCoordinates]+84',151.14329528809) -- Y Coord
writeFloat('[PlayerCoordinates]+88',107.22196960449) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134351
"Order 54 Part 1 - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',154.8953704834) -- X Coord
writeFloat('[PlayerCoordinates]+84',147.11311340332) -- Y Coord
writeFloat('[PlayerCoordinates]+88',106.16584777832) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134352
"Order 54 Part 1 - Cryptobiote"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',128.60760498047) -- X Coord
writeFloat('[PlayerCoordinates]+84',66.32152557373) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.20802307129) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134353
"Order 54 Part 1 - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',100.65667724609) -- X Coord
writeFloat('[PlayerCoordinates]+84',70.368103027344) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.15480804443) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134354
"Order 54 Part 1 - [World War 2 Battlefield] - Find Sewer Entrance"
FF0080
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 65.41815186)
writeFloat('[PlayerCoordinates]+84', 95.5856781)
writeFloat('[PlayerCoordinates]+88', 103.990715)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134355
"Order 54 Part 1 - Hematic Grenade (Lvl 1)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',73.924468994141) -- X Coord
writeFloat('[PlayerCoordinates]+84',13.063589096069) -- Y Coord
writeFloat('[PlayerCoordinates]+88',95.515007019043) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134356
"Order 54 Part 1 - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',91.071022033691) -- X Coord
writeFloat('[PlayerCoordinates]+84',17.841133117676) -- Y Coord
writeFloat('[PlayerCoordinates]+88',96.696441650391) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134357
"Order 54 Part 2 - [World War 2 Battlefield] - Find BB (Cutscene)"
FF0080
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 96.21802521)
writeFloat('[PlayerCoordinates]+84', 10.64340496)
writeFloat('[PlayerCoordinates]+88', 99.19300079)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134358
"Order 54 Part 1 - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',90.847770690918) -- X Coord
writeFloat('[PlayerCoordinates]+84',-7.0623841285706) -- Y Coord
writeFloat('[PlayerCoordinates]+88',104.63076782227) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134359
"Order 54 Part 3 - [World War 2 Battlefield] - Exit Sewer"
FF0080
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 81.93144989)
writeFloat('[PlayerCoordinates]+84', -12.43567181)
writeFloat('[PlayerCoordinates]+88', 104.5936813)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134360
"Defeat Clifford"
1
134361
"Items"
1
134362
"Order 54 Part 4 - Assault Rifle (Lvl 2)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',57.192081451416) -- X Coord
writeFloat('[PlayerCoordinates]+84',3.8205513954163) -- Y Coord
writeFloat('[PlayerCoordinates]+88',107.15380859375) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134363
"Order 54 Part 4 - Cryptobiote"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',28.19003868103) -- X Coord
writeFloat('[PlayerCoordinates]+84',-8.2350635528564) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.73412322998) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134364
"Order 54 Part 4 - Shotgun (Lvl 2)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',25.108293533325) -- X Coord
writeFloat('[PlayerCoordinates]+84',1.0091278553009) -- Y Coord
writeFloat('[PlayerCoordinates]+88',110.26573181152) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134365
"Order 54 Part 4 - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',13.461980819702) -- X Coord
writeFloat('[PlayerCoordinates]+84',17.466979980469) -- Y Coord
writeFloat('[PlayerCoordinates]+88',109.655128479) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134366
"Order 54 Part 4 - Hematic Grenade (Lvl 1)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',20.577871322632) -- X Coord
writeFloat('[PlayerCoordinates]+84',66.427574157715) -- Y Coord
writeFloat('[PlayerCoordinates]+88',107.59117126465) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134367
"Order 54 Part 4 - Cryptobiote"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2.9534058570862) -- X Coord
writeFloat('[PlayerCoordinates]+84',64.393989562988) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.06653594971) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134368
"Order 54 Part 4 - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1.9661084413528) -- X Coord
writeFloat('[PlayerCoordinates]+84',68.388236999512) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.05534362793) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134369
"Order 54 Part 4 - Cryptobiote"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-54.527851104736) -- X Coord
writeFloat('[PlayerCoordinates]+84',60.937953948975) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.2183303833) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134370
"Order 54 Part 4 - Armor Plate (Lvl 1)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-56.325424194336) -- X Coord
writeFloat('[PlayerCoordinates]+84',62.175884246826) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.03351593018) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134371
"Order 54 Part 4 - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-6.7855658531189) -- X Coord
writeFloat('[PlayerCoordinates]+84',20.243032455444) -- Y Coord
writeFloat('[PlayerCoordinates]+88',108.81187438965) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134372
"Order 54 Part 4 - Cryptobiote"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-0.78732627630234) -- X Coord
writeFloat('[PlayerCoordinates]+84',16.391330718994) -- Y Coord
writeFloat('[PlayerCoordinates]+88',109.08322906494) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134373
"Order 54 Part 4 - Encounter 1 Vantage Point"
FF0080
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -14.62163544)
writeFloat('[PlayerCoordinates]+84', 21.19772148)
writeFloat('[PlayerCoordinates]+88', 115.4032669)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134374
"Order 54 Part 4 - Encounter 2/3/4 Vantage Point"
FF0080
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -19.00231171)
writeFloat('[PlayerCoordinates]+84', 40.26580429)
writeFloat('[PlayerCoordinates]+88', 115.4010239)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134375
"Accept Order 56 from Mountain Knot City"
1
134376
"Order 56 Part 1 - Collect Winter Clothes"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -390.1298828)
writeFloat('[PlayerCoordinates]+84', 327.2009888)
writeFloat('[PlayerCoordinates]+88', 602.1593628)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134377
"Order 56 Part 2 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134378
"read email: "[Recovery Request] [V] I Need You to Secure a Chip in BT Country""
1
134379
"Accept Order 75 from Mountain Knot City"
1
134380
"Order 75 Part 1 - Pick up Item"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -899.3306274)
writeFloat('[PlayerCoordinates]+84', 23.67071533)
writeFloat('[PlayerCoordinates]+88', 528.2859497)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134381
"Order 75 Part 2 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134382
"Accept Order 55 from Mountain Knot City"
1
136445
"Order 55 - Song 24: Low Roar - Without You (head south)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1137.5545654297) -- X Coord
writeFloat('[PlayerCoordinates]+84',-116.16165161133) -- Y Coord
writeFloat('[PlayerCoordinates]+88',545.82110595703) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134383
"Order 55 - Deliver Mama's Corpse to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1221.0745849609)
writeFloat('[PlayerCoordinates]+84', -222.158462524411367)
writeFloat('[PlayerCoordinates]+88', 532.82336425781)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134384
"This takes you to Episode 8: Heartman"
1
134385
"Episode 8: Heartman"
1
134386
"Accept Order 58, 59 from Heartman's Lab"
1
134387
"Order 58 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136446
"Order 59 - Song 25: Low Roar - Patience (Head South)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1113.2360839844) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1116.4340820313) -- Y Coord
writeFloat('[PlayerCoordinates]+88',510.12295532227) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134388
"Order 59 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134389
"read email: "For a Least Meal, Only Pizza Will Suffice""
1
134390
"Head to Mountain Knot City to Receive Order 57"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134391
"Order 57 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1749.9689941406)
writeFloat('[PlayerCoordinates]+84', 1971.5640869141)
writeFloat('[PlayerCoordinates]+88', 211.4801940918)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134392
"Head back to Paleontologist to Accept Order 60"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134393
"Order 60 Part 1 - Pick Up Item 1/5 (Wear Oxygen Mask)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1371.434082)
writeFloat('[PlayerCoordinates]+84', -1346.460815)
writeFloat('[PlayerCoordinates]+88', 340.1844788)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134394
"Order 60 Part 1 - Pick Up Item 2/5 (Wear Oxygen Mask)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1353.569458)
writeFloat('[PlayerCoordinates]+84', -1339.365601)
writeFloat('[PlayerCoordinates]+88', 343.8174438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134395
"Order 60 Part 1 - Pick Up Item 3/5 (Wear Oxygen Mask)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1361.869019)
writeFloat('[PlayerCoordinates]+84', -1338.710327)
writeFloat('[PlayerCoordinates]+88', 340.010376)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134396
"Order 60 Part 1 - Pick Up Item 4/5 (Wear Oxygen Mask)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1359.21936)
writeFloat('[PlayerCoordinates]+84', -1337.108765)
writeFloat('[PlayerCoordinates]+88', 340.9216003)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134397
"Order 60 Part 1 - Pick Up Item 5/5 (Wear Oxygen Mask)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1378.189209)
writeFloat('[PlayerCoordinates]+84', -1342.410278)
writeFloat('[PlayerCoordinates]+88', 341.2489929)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134398
"Order 60 Part 2 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134399
"Accept Order 61 from Paleontologist"
1
134400
"Order 61 Part 1 - Item 1/5 is provided from Order acceptance"
1
134401
"Order 61 Part 1 - Pick Up Item 2/5"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2011.03418)
writeFloat('[PlayerCoordinates]+84', -983.1091309)
writeFloat('[PlayerCoordinates]+88', 315.8219299)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134402
"Order 61 Part 1 - Pick Up Item 3/5"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2026.147949)
writeFloat('[PlayerCoordinates]+84', -1060.050537)
writeFloat('[PlayerCoordinates]+88', 322.1638184)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134403
"Order 61 Part 1 - Pick Up Item 4/5"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.995605)
writeFloat('[PlayerCoordinates]+84', -1045.139893)
writeFloat('[PlayerCoordinates]+88', 318.0083313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134404
"Order 61 Part 1 - Pick Up Item 5/5"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1928.153442)
writeFloat('[PlayerCoordinates]+84', -1009.481628)
writeFloat('[PlayerCoordinates]+88', 328.285553)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134405
"Order 61 Part 2 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136447
"Inbetween Order 61 and 62 "Head back to Heartman's Lab" - Song 26: Low Roar - Rolling Over"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1603.5187988281) -- X Coord
writeFloat('[PlayerCoordinates]+84',-507.93319702148) -- Y Coord
writeFloat('[PlayerCoordinates]+88',581.24395751953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134406
"Go to Lake Knot City and head to Private Room to receive new emails"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134407
"read email: "[Test Order] Could You Please Go Look for My Cube?""
1
134408
"Collect Lost Cargo (Cube 5)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1127.741089)
writeFloat('[PlayerCoordinates]+84', -706.7249756)
writeFloat('[PlayerCoordinates]+88', 640.6445312)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134409
"Deliver Lost Cargo to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134410
"Head to Heartman's Lab to Accept Order 62 (Inside His Office)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136448
"Order 62: Part 1 - Chiral Relay - Song 27: Silent Poets - Almost Nothing feat. Okay Kaya"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2436.8706054688) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1466.6159667969) -- Y Coord
writeFloat('[PlayerCoordinates]+88',268.55755615234) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134411
"Order 62 Part 1 - Deliver to Chiral Relay"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2557.8117675781)
writeFloat('[PlayerCoordinates]+84', -2013.41796875)
writeFloat('[PlayerCoordinates]+88', 93.71546936)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134412
"Order 62 Part 2 - Start of BT Area (you might have a codec conversation going south)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2640.370117)
writeFloat('[PlayerCoordinates]+84', -2037.759888)
writeFloat('[PlayerCoordinates]+88', 86.67215729)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134413
"Order 62 Part 2 - Next to BTs (they wont spawn until the heavy rain starts (let them drown you)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2692.606201)
writeFloat('[PlayerCoordinates]+84', -2152.452148)
writeFloat('[PlayerCoordinates]+88', 83.84473419)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134414
"Find a Way to Cross the Tar Belt - Cause Buildings to Spawn"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2688.777832)
writeFloat('[PlayerCoordinates]+84', -2322.387451)
writeFloat('[PlayerCoordinates]+88', 86.26888275)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134415
"Die Hard-Man may speak to you after you drop down to the next bulding (East)"
1
134416
"Find a Way to Cross the Tar Belt - Cause Last Buildings to Spawn"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2612.965576)
writeFloat('[PlayerCoordinates]+84', -2598.32251)
writeFloat('[PlayerCoordinates]+88', 87.41194916)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134417
"At Waypoint"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2603.3293457031) -- X Coord
writeFloat('[PlayerCoordinates]+84',-2657.1179199219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',81.047027587891) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134418
"This takes you to Episode 9: Higgs"
1
134419
"Episode 9: Higgs"
1
134420
"Connect to Q-pid: Center North of Edge Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -189.4738922)
writeFloat('[PlayerCoordinates]+84', 952.4784546)
writeFloat('[PlayerCoordinates]+88', 99.27870941)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134421
"Order 63 Part 1 - Cutscene (Heading West) after Leaving Distribution Center North of Edge Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -225.0032654)
writeFloat('[PlayerCoordinates]+84', 715.1629028)
writeFloat('[PlayerCoordinates]+88', 109.9954147)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134422
"Order 63 Part 2 - Edge Knot City - Activate Chiral Network"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -624.60943603516)
writeFloat('[PlayerCoordinates]+84', 156.75914001465)
writeFloat('[PlayerCoordinates]+88', 99.559226989746)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134423
"Find the source of the noise > head up ramp for cutscene & BT Boss Battle #3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-607.67395019531) -- X Coord
writeFloat('[PlayerCoordinates]+84',184.57713317871) -- Y Coord
writeFloat('[PlayerCoordinates]+88',104.7926940918) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134424
"Find the source of the noise > head up ramp for cutscene & Boss Battle #3 (BT#3)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -624.60943603516)
writeFloat('[PlayerCoordinates]+84', 156.75914001465)
writeFloat('[PlayerCoordinates]+88', 99.559226989746)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134425
"Order 64 - Eliminate the Big BT"
1
134426
"Disable Infinite Health Before BT Dies (You Repatriate)"
0000FF
1
134427
"Head Back to Edge Knot City and go to Private Room to Fragile Jump to the Beach"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -624.60943603516)
writeFloat('[PlayerCoordinates]+84', 156.75914001465)
writeFloat('[PlayerCoordinates]+88', 99.559226989746)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134428
"Order 65 - Elimination: Higgs"
1
134429
"Disable Infinite Health Before Higgs Loses at Punchout (You Repatriate)"
0000FF
1
134430
"Episode 10: Die Hard-Man"
1
136453
"Song 28: Low Roar - Not Around (head north)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2462.8950195313) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1898.185546875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',91.888442993164) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136452
"Song 29: Silent Poets - Almost Nothing feat. Okay Kaya (head north) (Also cutscene 1 instead of other) "
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1647.5798339844) -- X Coord
writeFloat('[PlayerCoordinates]+84',-816.35247802734) -- Y Coord
writeFloat('[PlayerCoordinates]+88',459.33135986328) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134431
"Head for Lake Knot City - Cutscene 1 with Deadman (Head North)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1871.51953125) -- X Coord
writeFloat('[PlayerCoordinates]+84',-601.76788330078) -- Y Coord
writeFloat('[PlayerCoordinates]+88',502.23913574219) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134432
"(Optional) Head for Lake Knot City - Fabricate a Vehicle at Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134433
"Head for Lake Knot City - Cutscene 2 with Deadman (Head North)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1498.0712890625) -- X Coord
writeFloat('[PlayerCoordinates]+84',1568.1669921875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',229.3157043457) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134434
"Head for Lake Knot City - Cutscene 3 with Deadman (Head North)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2002.8326416016) -- X Coord
writeFloat('[PlayerCoordinates]+84',1161.9097900391) -- Y Coord
writeFloat('[PlayerCoordinates]+88',180.37614440918) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134435
"read e-mail: "A Final Request for Pizza""
1
134436
"Head to First Prepper to Accept Order 66"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136454
"Song 30: Low Roar - Please Don't Stop (Chapter 1) (head southeast)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',355.77499389648) -- X Coord
writeFloat('[PlayerCoordinates]+84',1943.9074707031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',175.68255615234) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134437
"Order 66 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1749.9689941406)
writeFloat('[PlayerCoordinates]+84', 1971.5640869141)
writeFloat('[PlayerCoordinates]+88', 211.4801940918)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134438
"Head for Lake Knot City - Cutscene 4 with Deadman & Heartman (Head North)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2395.6638183594) -- X Coord
writeFloat('[PlayerCoordinates]+84',1612.8059082031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',202.50698852539) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134439
"Head for Lake Knot City - Head North for Cutscene & start Episode 11: Clifford Unger"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2461.6921386719) -- X Coord
writeFloat('[PlayerCoordinates]+84',1742.5263671875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',215.24346923828) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134440
"Episode 11: Clifford Unger"
1
134441
"Items"
1
134442
"Order 67 Part 1 - Blood Bag"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -115.0857162)
writeFloat('[PlayerCoordinates]+84', 218.5013123)
writeFloat('[PlayerCoordinates]+88', 126.7442245)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134443
"Order 67 Part 1 - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -31.00772667)
writeFloat('[PlayerCoordinates]+84', 173.7985535)
writeFloat('[PlayerCoordinates]+88', 131.13797)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134444
"Order 67 Part 1 - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -37.74910736)
writeFloat('[PlayerCoordinates]+84', 157.6686554)
writeFloat('[PlayerCoordinates]+88', 129.969101)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134445
"Order 67 Part 1 - Blood Bag (use this and walk forward until you see Anti BT Handguns spawn if you want them)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -22.63981056)
writeFloat('[PlayerCoordinates]+84', 159.1943665)
writeFloat('[PlayerCoordinates]+88', 131.0270386)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134446
"Order 67 Part 1 - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -17.88534546)
writeFloat('[PlayerCoordinates]+84', 124.5670013)
writeFloat('[PlayerCoordinates]+88', 128.9736023)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134447
"Order 67 Part 1 - Anti BT Handgun (Lvl 1) Pickup"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 8.052550316)
writeFloat('[PlayerCoordinates]+84', 61.39998627)
writeFloat('[PlayerCoordinates]+88', 128.6885071)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134448
"Order 67 Part 1 - Anti BT Handgun (Lvl 1) Pickup"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 62.84210968)
writeFloat('[PlayerCoordinates]+84', 58.78548813)
writeFloat('[PlayerCoordinates]+88', 134.996933)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134449
"Order 67 Part 1 - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 80.01526642)
writeFloat('[PlayerCoordinates]+84', 48.96261215)
writeFloat('[PlayerCoordinates]+88', 136.4726868)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134450
"Order 67 Part 1 - Blood Bag"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 144.4800568)
writeFloat('[PlayerCoordinates]+84', 23.28774643)
writeFloat('[PlayerCoordinates]+88', 144.5024719)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134451
"Order 67 Part 1 - Cryptobiote"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 157.6137238)
writeFloat('[PlayerCoordinates]+84', -23.66797256)
writeFloat('[PlayerCoordinates]+88', 155.6232758)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134452
"Order 67 Part 1 - Move forward for Waypoint/Cutscene"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 157.6137238)
writeFloat('[PlayerCoordinates]+84', -23.66797256)
writeFloat('[PlayerCoordinates]+88', 155.6232758)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134453
"Items"
1
134454
"Order 67 Part 2 - Boss Fight - Assault Rifle 3 & Blood Bag"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 142.2155914)
writeFloat('[PlayerCoordinates]+84', -73.06476593)
writeFloat('[PlayerCoordinates]+88', 152.4251404)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134455
"Order 67 Part 2 - Boss Fight - Hematic Grenade (Lvl 2)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',87.689529418945) -- X Coord
writeFloat('[PlayerCoordinates]+84',-251.10562133789) -- Y Coord
writeFloat('[PlayerCoordinates]+88',146.15476989746) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134456
"Order 67 Part 2 - Boss Fight - Anti-BT Handgun (Lvl 2)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',88.140602111816) -- X Coord
writeFloat('[PlayerCoordinates]+84',-197.3458404541) -- Y Coord
writeFloat('[PlayerCoordinates]+88',157.58711242676) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134457
"Order 67 Part 2 - Boss Fight - 1st Location Vantage Point"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 85.27231598)
writeFloat('[PlayerCoordinates]+84', -158.7615051)
writeFloat('[PlayerCoordinates]+88', 160.6088867)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134458
"Order 67 Part 2 - Boss Fight - 1st Location (Directly Behind Cliff)"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',73.313987731934) -- X Coord
writeFloat('[PlayerCoordinates]+84',-124.9591217041) -- Y Coord
writeFloat('[PlayerCoordinates]+88',144.91435241699) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134459
"Items"
1
134460
"Order 67 Part 2 - Boss Fight - Blood Bag"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 76.16706848)
writeFloat('[PlayerCoordinates]+84', -183.7270203)
writeFloat('[PlayerCoordinates]+88', 151.8994751)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134461
"Order 67 Part 2 - Boss Fight - Armor Plate (Lvl 2)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 128.9989166)
writeFloat('[PlayerCoordinates]+84', -177.8865509)
writeFloat('[PlayerCoordinates]+88', 162.1077271)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134462
"Order 67 Part 2 - Boss Fight - Blood Bag"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 150.1482086)
writeFloat('[PlayerCoordinates]+84', -196.3136749)
writeFloat('[PlayerCoordinates]+88', 150.5882568)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134463
"Order 67 Part 2 - Boss Fight - Assault Rifle (Lvl 3)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 156.012085)
writeFloat('[PlayerCoordinates]+84', -191.0361938)
writeFloat('[PlayerCoordinates]+88', 151.2233734)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134464
"Order 67 Part 2 - Boss Fight - 2nd Location Vantage Point: North Side"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 87.70005035)
writeFloat('[PlayerCoordinates]+84', -197.7876892)
writeFloat('[PlayerCoordinates]+88', 157.3880157)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134465
"Note: Spawns in Multiple Locations"
1
134466
"Order 67 Part 2 - Boss Fight - 2nd Location Vantage Point: On top of House (you can't jump off)"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',169.31996154785) -- X Coord
writeFloat('[PlayerCoordinates]+84',-211.42315673828) -- Y Coord
writeFloat('[PlayerCoordinates]+88',159.67163085938) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134467
"Order 67 Part 2 - Boss Fight - 2nd Location Vantage Point: Behind House (that you can't jump off of)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',175.53594970703) -- X Coord
writeFloat('[PlayerCoordinates]+84',-216.82836914063) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.92219543457) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134468
"Order 67 Part 2 - Boss Fight - 2nd Location Vantage Point: Behind fallen tree"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',128.99089050293) -- X Coord
writeFloat('[PlayerCoordinates]+84',-242.39428710938) -- Y Coord
writeFloat('[PlayerCoordinates]+88',147.87367248535) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134469
"Order 67 Part 2 - Boss Fight - 2nd Location Vantage Point: Behind fallen tree behind a Potential Boss Spawn Location"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',113.89720916748) -- X Coord
writeFloat('[PlayerCoordinates]+84',-250.7696685791) -- Y Coord
writeFloat('[PlayerCoordinates]+88',147.6918182373) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134470
"Order 67 Part 2 - Boss Fight - 3rd Location (Get in Crawl Position)"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',106.48251342773) -- X Coord
writeFloat('[PlayerCoordinates]+84',-180.63412475586) -- Y Coord
writeFloat('[PlayerCoordinates]+88',162.69920349121) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134471
"Order 67 Part 2 - Boss Fight - 4th Location Vantage Point"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 133.1217957)
writeFloat('[PlayerCoordinates]+84', -181.3889923)
writeFloat('[PlayerCoordinates]+88', 162.4309082)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134472
"This takes you to Episode 12: Bridges"
1
134473
"Episode 12: Bridges"
1
136455
"Order 68 - Song 31: Low Roar - Tonight, Tonight, Tonight"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1646.8338623047) -- X Coord
writeFloat('[PlayerCoordinates]+84',-404.37237548828) -- Y Coord
writeFloat('[PlayerCoordinates]+88',148.97503662109) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134474
"Order 68 - Part 1 - BT #1 [Go down the hill (east), can avoid and not kill]"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-969.38354492188) -- X Coord
writeFloat('[PlayerCoordinates]+84',85.045257568359) -- Y Coord
writeFloat('[PlayerCoordinates]+88',197.7833404541) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134475
"Order 68 - Part 2 - BT #2 Final BT Battle [head towards waypoint]"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1157.4947509766) -- X Coord
writeFloat('[PlayerCoordinates]+84',816.10302734375) -- Y Coord
writeFloat('[PlayerCoordinates]+88',139.15963745117) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134476
"Item Spawns [Random Spawns based on start of fight, items may not be there]"
1
134477
"Order 68 - Part 2 - BT #2 Final BT Battle - Quadruple Rocket Launcher"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1205.170166)
writeFloat('[PlayerCoordinates]+84', 804.644104)
writeFloat('[PlayerCoordinates]+88', 142.6672668)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134478
"Order 68 - Part 2 - BT #2 Final BT Battle - Quadruple Rocket Launcher"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1205.1315917969) -- X Coord
writeFloat('[PlayerCoordinates]+84',862.7451171875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',136.91021728516) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134479
"Order 68 - Part 2 - BT #2 Final BT Battle - Quadruple Rocket Launcher"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1212.5667724609) -- X Coord
writeFloat('[PlayerCoordinates]+84',847.30108642578) -- Y Coord
writeFloat('[PlayerCoordinates]+88',138.07791137695) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134480
"Order 68 - Part 2 - BT #2 Final BT Battle - Blood Bag"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1220.4798583984) -- X Coord
writeFloat('[PlayerCoordinates]+84',840.71368408203) -- Y Coord
writeFloat('[PlayerCoordinates]+88',139.10534667969) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136456
"Order 68 - Part 3 - Song 32: Low Roar - Please Don't Stop (Chapter 2) (head north)"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1266.1248779297) -- X Coord
writeFloat('[PlayerCoordinates]+84',830.42504882813) -- Y Coord
writeFloat('[PlayerCoordinates]+88',142.83079528809) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134481
"Order 68 - Part 3 - Deliver to Capital Knot City Isolation Ward"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1694.714844)
writeFloat('[PlayerCoordinates]+84', 1056.515259)
writeFloat('[PlayerCoordinates]+88', 136.5499115)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134482
"This takes you to Episode 13: Sam Strand"
1
134483
"Episode 13: Sam Strand"
1
134484
"Order 69 Part 1 - Walk around aimlessly, game will automatically trigger cutscene"
1
134485
"Order 69 Part 2 - De-equip gun & head towards Amelie to hug her"
1
134486
"Order 69 Part 3 - [Repeats 5 Times] After credits stop you can move a few steps to start the next cutscene"
1
134487
"Order 69 Part 4 - Head towards Amelie [Towards the Water] (after cutscene requiring you to press button to reconnect with the living)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',83.479370117188) -- X Coord
writeFloat('[PlayerCoordinates]+84',31.043361663818) -- Y Coord
writeFloat('[PlayerCoordinates]+88',103.44848632813) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134488
"This takes you to Episode 14: Lou"
1
134489
"Episode 14: Lou"
1
136457
"Order 70 Part 1 - Song 33: Ludvig Forssell - BB's Theme"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1669.6937255859) -- X Coord
writeFloat('[PlayerCoordinates]+84',1018.126159668) -- Y Coord
writeFloat('[PlayerCoordinates]+88',141.13505554199) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134490
"Order 70 Part 1 - Cutscene Outside of Incinerator West of Capital Knot City"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',574.25170898438) -- X Coord
writeFloat('[PlayerCoordinates]+84',365.76181030273) -- Y Coord
writeFloat('[PlayerCoordinates]+88',238.32539367676) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134491
"Order 70 Part 2 - Deliver to Incinerator West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 526.4191284)
writeFloat('[PlayerCoordinates]+84', 328.3183594)
writeFloat('[PlayerCoordinates]+88', 238.3401031)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134492
"This takes you to Episode 15: Tomorrow Is In Your Hands"
1
134493
"Episode 15: Tomorrow Is In Your Hands"
1
134494
"Fragile Jump to Distribution Center South of Lake Knot City and Accept Order 79"
1
136458
"Order 79 - Beginning"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',253.6429901123) -- X Coord
writeFloat('[PlayerCoordinates]+84',522.22625732422) -- Y Coord
writeFloat('[PlayerCoordinates]+88',301.75085449219) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136459
"Order 79 - Open Control Panel #2 at Ruined Factory and Neutralize all Targets"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',341.39114379883) -- X Coord
writeFloat('[PlayerCoordinates]+84',517.20544433594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136460
"Order 79 - Open Control Panel #3 at Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',370.11755371094) -- X Coord
writeFloat('[PlayerCoordinates]+84',582.50012207031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.35571289063) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136461
"Order 79 - Deliver items to Ruined Factory Terminal"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',343.82635498047) -- X Coord
writeFloat('[PlayerCoordinates]+84',592.18804931641) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.88571166992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136484
"Order 79 - After delivering items to terminal, head towards open door for Song 34: Midge Ure - Fragile"
00FF00
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',343.82635498047) -- X Coord
writeFloat('[PlayerCoordinates]+84',592.18804931641) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.88571166992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136462
"Head up ladder for a cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',358.80374145508) -- X Coord
writeFloat('[PlayerCoordinates]+84',583.99438476563) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.38488769531) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136463
"Teleport back to Vehicle (if you used it)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',241.1863861084) -- X Coord
writeFloat('[PlayerCoordinates]+84',539.00946044922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',307.48614501953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136485
"read email: [Recovery Request] [V] My Chip! Grab it Back from the Terrorists! and teleport to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134495
"Fragile Jump to Distribution Center South of Lake Knot City and accept Order 76"
1
134496
"Order 76 Part 1 - [V] Neutralize the terrorists in the Ruins (Entrance of Lower Area)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1191.055664)
writeFloat('[PlayerCoordinates]+84', 1673.424194)
writeFloat('[PlayerCoordinates]+88', 200.9716797)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134497
"Order 76 Part 1 - [V] Neutralize the terrorists in the Ruins (Exit of Lower Area, On Top)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1231.9338378906) -- X Coord
writeFloat('[PlayerCoordinates]+84',1772.9545898438) -- Y Coord
writeFloat('[PlayerCoordinates]+88',205.79541015625) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134498
"Order 76 Part 2 - [V] Recover the Chip from Ruined Shelter Private Locker"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1322.494751)
writeFloat('[PlayerCoordinates]+84', 1781.724731)
writeFloat('[PlayerCoordinates]+88', 200.0786896)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134499
"Order 76 Part 3 - [V] Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134500
"read email: Have You Been Getting Some Weird Emails?"
1
134501
"Fabricate a PCC Lv.2 and withdraw 800 metal to build a bridge and a ladder"
1
134502
"Cube 6 Part 1 - build a bridge at this location, 80m long (change bridge length) or just use the teleport below"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',954.42932128906) -- X Coord
writeFloat('[PlayerCoordinates]+84',1930.2130126953) -- Y Coord
writeFloat('[PlayerCoordinates]+88',169.4111328125) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134503
"Cube 6 Part 1 - place a ladder to the other side"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 972.3163452)
writeFloat('[PlayerCoordinates]+84', 2064.905762)
writeFloat('[PlayerCoordinates]+88', 168.3616333)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134504
"Cube 6 Part 1 - Pick-up Lost Cargo: Final Companion Cube (Cube 6)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 982.8112183)
writeFloat('[PlayerCoordinates]+84', 2123.182861)
writeFloat('[PlayerCoordinates]+88', 187.7253876)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134505
"Cube 6 Part 2 - Deliver to the Incinerator West of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -322.81805419922)
writeFloat('[PlayerCoordinates]+84', 2191.2136230469)
writeFloat('[PlayerCoordinates]+88', 218.59948730469)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136488
"Song 35: Silent Poets - Asylums for the Feeling (Chapter 15 Only) Near Memory Chip 51"
00FF00
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 403.8961792)
writeFloat('[PlayerCoordinates]+84', -2104.087891)
writeFloat('[PlayerCoordinates]+88', 284.1140442)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134506
"Director's Cut Episode Quests"
008000
1
134507
"Eastern Region"
1
136385
"Accept Order 77 from Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136386
"Order 77 - Outside Entrance of Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',120.52124786377) -- X Coord
writeFloat('[PlayerCoordinates]+84',452.49322509766) -- Y Coord
writeFloat('[PlayerCoordinates]+88',252.72410583496) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136387
"Note: I had to do standard missions from this location to get Order 77 to unlock in late-game"
1
136388
"Order 77 - Pick up item 4 items at Ruined Factory MULEs Postbox"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',277.41485595703) -- X Coord
writeFloat('[PlayerCoordinates]+84',519.83526611328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136389
"Order 77 - Deliver to Distribution Center West of Capital Knot City & Accept Order 78"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134513
"Order 78 - Open Control Panel #1 at Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',277.41485595703) -- X Coord
writeFloat('[PlayerCoordinates]+84',519.83526611328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134514
"Order 78 - Pick up 5 item from MULEs Postbox"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',341.39114379883) -- X Coord
writeFloat('[PlayerCoordinates]+84',517.20544433594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134515
"Order 78 - Teleport back to Vehicle (if you used it)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',241.1863861084) -- X Coord
writeFloat('[PlayerCoordinates]+84',539.00946044922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',307.48614501953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134516
"Order 78 - Deliver to Distribution Center West of Capital Knot City & Accept Order 79"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134517
"Order 79 - Beginning"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',253.6429901123) -- X Coord
writeFloat('[PlayerCoordinates]+84',522.22625732422) -- Y Coord
writeFloat('[PlayerCoordinates]+88',301.75085449219) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134518
"Order 79 - Open Control Panel #2 at Ruined Factory and Neutralize all Targets"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',341.39114379883) -- X Coord
writeFloat('[PlayerCoordinates]+84',517.20544433594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134519
"Order 79 - Open Control Panel #3 at Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',370.11755371094) -- X Coord
writeFloat('[PlayerCoordinates]+84',582.50012207031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.35571289063) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134520
"Order 79 - Deliver items to Ruined Factory Terminal"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',343.82635498047) -- X Coord
writeFloat('[PlayerCoordinates]+84',592.18804931641) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.88571166992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134521
"Head up ladder for a cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',358.80374145508) -- X Coord
writeFloat('[PlayerCoordinates]+84',583.99438476563) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.38488769531) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134522
"Teleport back to Vehicle (if you used it)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',241.1863861084) -- X Coord
writeFloat('[PlayerCoordinates]+84',539.00946044922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',307.48614501953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134523
"Central Region"
1
134524
"Accept Order 80 from Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134525
"Order 80 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134526
"Accept Order 81 from Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134527
"Order 81 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134528
"Accept Order 82 from Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134529
"Order 82 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134530
"Accept Order 83 from Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134531
"Order 83 - Near Rescue Area (Conversation/cutscene moving southeast, near the water)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2123.7663574219) -- X Coord
writeFloat('[PlayerCoordinates]+84',-697.38775634766) -- Y Coord
writeFloat('[PlayerCoordinates]+88',185.66040039063) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134532
"Order 83 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136432
"Accept Order 84 from Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136433
"Order 84 - Head east to rescue porter"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-879.98309326172) -- X Coord
writeFloat('[PlayerCoordinates]+84',454.32437133789) -- Y Coord
writeFloat('[PlayerCoordinates]+88',466.90200805664) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136434
"Order 84 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134536
"After turning in Order 82, Die-Hardman should tell you about Order 85, accept"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134537
"Order 85 - Head south (up hill) to rescue porter+cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2131.6853027344) -- X Coord
writeFloat('[PlayerCoordinates]+84',-302.28720092773) -- Y Coord
writeFloat('[PlayerCoordinates]+88',522.76147460938) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134538
"Order 85 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134539
"Vehicle"
1
134540
"Episode 2: Amelie"
1
134541
"Begins from turning in Order 11 & using Private Room to start cube 1"
1
134542
"Collect Lost Cargo: Companion Cube: Benjamin (Cube 1)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-221.97820219091) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-221.97820219091) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',466.27209304945) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',466.27209304945) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',146.09909057617) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',146.09909057617) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134543
"Deliver Lost Cargo: Companion Cube: Benjamin to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134544
"Accept Order 12 & 13 From Distribution Center West of Capital Knot City"
1
134545
"Order 12 - Pick up item from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 353.032836914063) --X1
writeDouble('[VehicleCoordinates]+8F8', 353.032836914063) --X2
writeDouble('[VehicleCoordinates]+D0', 810.902099609375) --Y1
writeDouble('[VehicleCoordinates]+900', 810.902099609375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 162.930827675191) -- Z1
writeDouble('[VehicleCoordinates]+908', 162.930827675191) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134546
"Order 12 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134547
"Order 13 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1442.88495919048) --X1
writeDouble('[VehicleCoordinates]+8F8', 1442.88495919048) --X2
writeDouble('[VehicleCoordinates]+D0', 690.599788112928) --Y1
writeDouble('[VehicleCoordinates]+900', 690.599788112928) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.302408912237) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.302408912237) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134548
"Accept Order 14 which gives you Hematic Grenades, then Accept Order 15 From Capital Knot City"
1
134549
"Order 15 Part 1 - Go to the BT Area / Defeat a BT With Hematic Grenades / Collect Chiral Crystals"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',950.59212994762) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',950.59212994762) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1090.0296475571) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1090.0296475571) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',134.83911188273) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',134.83911188273) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134550
"Order 15 Part 2 - Recycle Chiral Crystals at Distribution Center West of Capital Knot City "
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134551
"Order 14 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134552
"Head out of Port Knot City - First Boss Battle (BT#1)"
1
134553
"Order 16 - Eliminate BT"
1
134554
"(Player Only) Head Back to Port Knot City to Grab Bike"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134555
"Note: You need Ludens Fan to join UCA to receive Order 17, do standard missions / lost cargo before starting Episode 3"
1
134556
"Head for the Harbor - move forward for codec cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1974.3158114535) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1974.3158114535) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-688.10751520531) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-688.10751520531) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',147.96973239564) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',147.96973239564) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134557
"Head to Episode 3: Fragile / Central Region"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1983.4135742188) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1983.4135742188) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-743.91803722265) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-743.91803722265) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',147.96984863281) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',147.96984863281) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134558
"Episode 3: Fragile"
1
134559
"Read The Ludens Fan e-mail: "Delivery to Port Knot City" (Requires Ludens Fan having joined UCA)"
1
134560
"Use Fragile Jump in Private Room to go back to Port Knot City"
1
134561
"Head to Ludens Fan for Order 17"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 92.6874055161516) --X1
writeDouble('[VehicleCoordinates]+8F8', 92.6874055161516) --X2
writeDouble('[VehicleCoordinates]+D0', 540.118915277497) --Y1
writeDouble('[VehicleCoordinates]+900', 540.118915277497) -- Y2
writeDouble('[VehicleCoordinates]+D8', 206.047497367006) -- Z1
writeDouble('[VehicleCoordinates]+908', 206.047497367006) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134562
"Order 17 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134563
"Switch Back to Player until Order 23"
1
134564
"Accept Order 25 from Lake Knot City"
1
134565
"Order 25 - Reconstruct the road at the Auto Paver South of Lake Knot City "
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2442.0808190761) --X1
writeDouble('[VehicleCoordinates]+8F8', 2442.0808190761) --X2
writeDouble('[VehicleCoordinates]+D0', 1704.68666043396) --Y1
writeDouble('[VehicleCoordinates]+900', 1704.68666043396) -- Y2
writeDouble('[VehicleCoordinates]+D8', 210.021445795168) -- Z1
writeDouble('[VehicleCoordinates]+908', 210.021445795168) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134566
"Head back to Lake Knot City to Accept Order 24, 26"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134567
"Order 26 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1736.88663510808) --X1
writeDouble('[VehicleCoordinates]+8F8', 1736.88663510808) --X2
writeDouble('[VehicleCoordinates]+D0', 1964.92318763108) --Y1
writeDouble('[VehicleCoordinates]+900', 1964.92318763108) -- Y2
writeDouble('[VehicleCoordinates]+D8', 210.988873047901) -- Z1
writeDouble('[VehicleCoordinates]+908', 210.988873047901) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134568
"read email from William L: [Test Order] Find my Lost Cargo, Please!”"
1
134569
"Pick up "Lost Cargo: Companion Cube: William" (Cube 2)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1752.5912585269) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1752.5912585269) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1978.5656738281) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1978.5656738281) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',210.96188706119) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',210.96188706119) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134570
"Deliver "Lost Cargo: Companion Cube: William" to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134571
"Order 24 - Deliver to Distribution Center South of Lake Knot City "
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134572
"read email from Thomas Southerland [Recovery Request] [V] Track Down a Chip with a Weird Symbol"
1
134573
"Accept Order 71 from Distribution Center South of Lake Knot City"
1
134574
"Order 71 Part 1 - Pick up Item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1108.594193971) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1108.594193971) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',154.57180915374) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',154.57180915374) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',130.02378983142) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',130.02378983142) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134575
"Order 71 Part 2 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134576
"Accept Order 27 from Distribution Center South of Lake Knot City"
1
134577
"Order 27 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134578
"Accept Order 29 from Weather Station"
1
134579
"Order 29 - Build & Upgrade a Safe House near Weather Station"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',101.15994984375) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',101.15994984375) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-300.59229862793) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-300.59229862793) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',269.10366326416) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',269.10366326416) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134580
"Enter Private Room"
1
134581
"Head back to Weather Station to Accept Order 28"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134582
"Order 28 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134583
"Head to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134584
"Read email from Thomas Southerland [Test Order] You've Got to Find my Cube!"
1
134585
"Pick up "Lost Cargo: Companion Cube: Thomas (Cube 3) in Mule Camp"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',583.15432411758) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',583.15432411758) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',899.5262385672) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',899.5262385672) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',168.24000290659) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',168.24000290659) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134586
"Deliver Lost Cargo to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134587
"Accept Order 30, 31 from Distribution Center South of Lake Knot City"
1
134588
"Order 31 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134589
"Order 30 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134590
"Accept Order 32 from Junk Dealer"
1
134591
"Order 32 Part 1 - Item 1/7 (10kg/110kg)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1281.7566740454) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1281.7566740454) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-743.00415039063) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-743.00415039063) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',141.23886606171) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',141.23886606171) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134592
"Order 32 Part 1 - Item 2/7 (20kg/110kg)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1245.0435807217) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1245.0435807217) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-680.15679648117) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-680.15679648117) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',142.60170003162) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',142.60170003162) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134593
"Order 32 Part 1 - Item 3/7 (10kg/110kg)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1217.1066622753) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1217.1066622753) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-616.66609910759) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-616.66609910759) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',138.00972885772) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',138.00972885772) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134594
"Order 32 Part 1 - Item 4/7 (10kg/110kg)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1238.0110824557) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1238.0110824557) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-608.06921004559) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-608.06921004559) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',137.07388725488) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',137.07388725488) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134595
"Order 32 Part 1 - Item 5/7 (30kg/110kg)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1168.9775680847) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1168.9775680847) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-579.42477566535) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-579.42477566535) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',142.06197344716) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',142.06197344716) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134596
"Order 32 Part 1 - Item 6/7 (10kg/110kg)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1193.2856167388) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1193.2856167388) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-654.93442739786) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-654.93442739786) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',140.89786320647) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',140.89786320647) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134597
"Order 32 Part 1 - Item 7/7 (20kg/110kg)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1219.5497174326) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1219.5497174326) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-664.57678826063) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-664.57678826063) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',144.67206680931) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',144.67206680931) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134598
"Order 32 Part 2 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134599
"Accept Order 33 from Junk Dealer"
1
134600
"(Player Only) Order 33 - Deliver to Chiral Artist (carry by hand/no vehicle allowed)"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134601
"Accept Order 34 from Chiral Artist"
1
134602
"Order 34 doesn't allow cargo bag, turn in any lost cargo you have before accepting or drop them"
1
134603
"(Player Only) Order 34 - Reunite Junk Dealer with Chiral Artist (Carrying Live Body)"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134604
"Accept Order 35 from Junk Dealer"
1
134605
"Order 35 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134606
"Read email: "[Order] Delivery for a Prepper""
1
134607
"Accept Order 36, 37 from Distribution Center South of Lake Knot City"
1
134608
"Order 37 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134609
"Order 36 Part 1 - Recover items 1-3 from MULEs, (MULEs move around - this is original locations)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1382.5038065446) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1382.5038065446) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',151.73718180497) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',151.73718180497) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',133.25426710393) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',133.25426710393) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134610
"Order 36 Part 1 - Recover items 4-6 from MULEs (MULEs move around - this is original locations)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1430.8962281211) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1430.8962281211) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',207.7404221401) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',207.7404221401) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',133.71465610204) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',133.71465610204) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134611
"Order 36 Part 2 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134612
"***Don't Accept Order 38 Yet***"
1
134613
"Go to Private Room at Lake Knot City"
1
134614
"Read email from J: [Recovery Request] [V] Retrieve My Chip from the MULEs, Take Order 72"
1
134615
"Read email from T Southerland [Test Order] Sorry. More Lost Cargo for You..."
1
134616
"Accept Order 72 from Lake Knot City"
1
134617
"Order 72 - Retrieve V's chip from the MULEs"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2463.60405191884) --X1
writeDouble('[VehicleCoordinates]+8F8', 2463.60405191884) --X2
writeDouble('[VehicleCoordinates]+D0', 1354.73044474371) --Y1
writeDouble('[VehicleCoordinates]+900', 1354.73044474371) -- Y2
writeDouble('[VehicleCoordinates]+D8', 185.547360344177) -- Z1
writeDouble('[VehicleCoordinates]+908', 185.547360344177) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134618
"Pick up "Lost Cargo: Companion Cube: Southerland" (Cube 4)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',630.79047037213) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',630.79047037213) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1519.4968261719) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1519.4968261719) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',171.7691141011) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',171.7691141011) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134619
"Deliver Lost Cargo (Cube 4) to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134620
"Order 72 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134621
"Accept Order 38 from Lake Knot City"
1
134622
"Order 38 - Head to private room to talk to Fragile at Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134623
"Order 38 - Dispose of the Nuclear Bomb in a Crater Lake"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1666.062105244) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1666.062105244) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-740.76295635564) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-740.76295635564) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',129.80041794971) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',129.80041794971) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134624
"Order 38 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134625
"Walk back up the ramp to move to Episode 4: Unger"
1
134626
"Episode 4: Unger"
1
134627
"Begins after First Cliff Unger Boss Battle"
1
134628
"Back in Central Region,pick up your loot and read Peter Englert's email: "A Desperate Plea for a Second Pizza Pie""
1
134629
"Go to South Knot City terminal and Accept Order 40"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134630
"Order 40 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1736.88663510808) --X1
writeDouble('[VehicleCoordinates]+8F8', 1736.88663510808) --X2
writeDouble('[VehicleCoordinates]+D0', 1964.92318763108) --Y1
writeDouble('[VehicleCoordinates]+900', 1964.92318763108) -- Y2
writeDouble('[VehicleCoordinates]+D8', 210.988873047901) -- Z1
writeDouble('[VehicleCoordinates]+908', 210.988873047901) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134631
"Head to Mama's Lab to begin Episode 5: Mama & Initiate Cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1009.396828436) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1009.396828436) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-971.98017095754) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-971.98017095754) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',161.91209227038) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',161.91209227038) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134632
"Episode 5: Mama"
1
134633
"read email: "[Recovery Request] Resources Scattered by the SuperCell""
1
134634
"Accept Order 42 from Use Mama's Lab Terminal"
1
134635
"Order 42 Part 1 - Item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',600.64973149795) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',600.64973149795) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-794.1964415188) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-794.1964415188) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',82.427926642322) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',82.427926642322) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134636
"Order 42 Part 1 - Item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',520.04400634766) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',520.04400634766) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-824.94596513189) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-824.94596513189) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',82.515612609331) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',82.515612609331) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134637
"Order 42 Part 1 - Item 3/4 (up the hill)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',474.76308602824) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',474.76308602824) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-808.12756147231) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-808.12756147231) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',93.431674148964) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',93.431674148964) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134638
"Order 42 Part 1 - Item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',475.29597478376) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',475.29597478376) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-860.88427797152) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-860.88427797152) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',99.614696594235) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',99.614696594235) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134639
"Order 42 Part 2 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134640
"Head to Distribution Center South of Lake Knot City to Accept Order 41"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134641
"Order 41: Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134642
"Accept Order 43 from Waystation North of Mountain Knot City"
1
134643
"Order 43 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134644
"read email: "[Recovery Request][X] I've Lost Contact wit the Porter Who Recovered my Chip""
1
134645
"Accept Order 73 from Distribution Center North of Mountain Knot City, Don't Accept Order 44"
1
134646
"Order 73 Part 1 - Pick up Item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-813.31788909051) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-813.31788909051) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',2036.3410017922) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',2036.3410017922) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',283.13757774138) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',283.13757774138) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134647
"Order 73 Part 2 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134648
"Order 73 Part 3 - Pick Up the Body"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-828.03678531223) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-828.03678531223) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',2039.5769724147) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',2039.5769724147) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',286.91788191901) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',286.91788191901) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134649
"Order 73 Part 4 - Cremate the Body at Incinerator West of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -322.187921711329) --X1
writeDouble('[VehicleCoordinates]+8F8', -322.187921711329) --X2
writeDouble('[VehicleCoordinates]+D0', 2190.62475585938) --Y1
writeDouble('[VehicleCoordinates]+900', 2190.62475585938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 217.562371936685) -- Z1
writeDouble('[VehicleCoordinates]+908', 217.562371936685) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134650
"Accept Order 44 at the Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134651
"Order 44 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134652
"read email: "Yet Another Easnest Entreaty for Pizza""
1
134653
"Head to Timefall Farm to Accept Order 45 - Fresh Pizza Delivery"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134654
"(Player Only) Order 45 - Deliver to Peter Englert (Have to carry item with hand)"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1749.9689941406)
writeFloat('[PlayerCoordinates]+84', 1971.5640869141)
writeFloat('[PlayerCoordinates]+88', 211.4801940918)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134655
"(Player Only) Teleport back to Timefall Farm to get Vehicle back"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134656
"Head to Mama's Lab to be given Order 46 to change Lockne's Mind"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1013.66293989933) --X1
writeDouble('[VehicleCoordinates]+8F8', 1013.66293989933) --X2
writeDouble('[VehicleCoordinates]+D0', -973.060315833813) --Y1
writeDouble('[VehicleCoordinates]+900', -973.060315833813) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.76572519014) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.76572519014) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134657
"Exit Mama's Lab for Second BT Boss Battle (BT#2)"
1
134658
"Pick Mama back up if you dropped her"
1
134659
"Order 46 - Take Mama to Meet Lockne at Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134660
"This takes you to Episode 6: Deadman"
1
134661
"Episode 6: Deadman"
1
134662
"Fabricate a new Vehicle at Mountain Knot City"
1
134663
"read email: "[Recovery Request][V] The Porter Had Not One, but Two Chips""
1
134664
"Accept Order 74 at Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134665
"Order 74 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -762.880743824688) --X1
writeDouble('[VehicleCoordinates]+8F8', -762.880743824688) --X2
writeDouble('[VehicleCoordinates]+D0', 1811.14760256781) --Y1
writeDouble('[VehicleCoordinates]+900', 1811.14760256781) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.408607687459) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.408607687459) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134666
"Order 74 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134667
"Accept Order 47 & 48 from Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134668
"Head farther out for a codec cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1163.2700195313) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1163.2700195313) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',283.28322965674) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',283.28322965674) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',363.33783843376) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',363.33783843376) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134669
"Order 47 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134670
"Order 48 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134671
"Head Back to Mountain Knot City to Accept Order 49"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134672
"Order 49 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134673
"Accept Order 50 from Mountaineer"
1
134674
"Order 50 Part 1 - Pick up 2 items from Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134675
"Order 50 Part 2 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134676
"Accept Order 51 from Mountaineer"
1
134677
"Order 51 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134678
"Accept Order 52 from Photographer"
1
134679
"Order 52 Part 1 - Recover Camera in Mule Camp from MULE"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1684.5021777782) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1684.5021777782) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1073.3250537547) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1073.3250537547) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',219.57021851133) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',219.57021851133) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134680
"Order 52 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134681
"Head to Mountaineer to Accept Order 53"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134682
"Order 53 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134683
"Meet up with Deadman at the Cabin near Mountain Knot City"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-488.57446041625) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-488.57446041625) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',511.5093916701) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',511.5093916701) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',680.09379701355) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',680.09379701355) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134684
"This takes you to Episode 7: Clifford"
1
134685
"Episode 7: Clifford"
1
134686
"Switch back to Player until Order 54 complete [beating Clifford Unger]"
1
134687
"Fabricate a new Vehicle at Mountain Knot City"
1
134688
"Accept Order 56 from Mountain Knot City"
1
134689
"Order 56 Part 1 - Collect Winter Clothes [Bike, truck may not have room to land]"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-388.35748291016) -- X Coord
writeFloat('[PlayerCoordinates]+84',326.97692871094) -- Y Coord
writeFloat('[PlayerCoordinates]+88',601.85400390625) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134690
"Order 56 Part 2 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134691
"read email: "[Recovery Request] [V] I Need You to Secure a Chip in BT Country""
1
134692
"Accept Order 75 from Mountain Knot City"
1
134693
"Order 75 Part 1 - Pick up Item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-896.79904027848) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-896.79904027848) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',23.231763137342) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',23.231763137342) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',527.0592234669) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',527.0592234669) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134694
"Order 75 Part 2 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134695
"Accept Order 55 from Mountain Knot City"
1
134696
"Order 55 - Deliver Mama's Corpse to Heartman's Lab (Carrying Body)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134697
"This takes you to Episode 8: Heartman"
1
134698
"Episode 8: Heartman"
1
134699
"Accept Order 58, 59 from Heartman's Lab"
1
134700
"Order 58 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134701
"Order 59 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134702
"read email: "For a Least Meal, Only Pizza Will Suffice""
1
134703
"Head to Mountain Knot City to Receive Order 57"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134704
"Order 57 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1736.88663510808) --X1
writeDouble('[VehicleCoordinates]+8F8', 1736.88663510808) --X2
writeDouble('[VehicleCoordinates]+D0', 1964.92318763108) --Y1
writeDouble('[VehicleCoordinates]+900', 1964.92318763108) -- Y2
writeDouble('[VehicleCoordinates]+D8', 210.988873047901) -- Z1
writeDouble('[VehicleCoordinates]+908', 210.988873047901) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134705
"Head back to Paleontologist to Accept Order 60"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134706
"Order 60 Part 1 - Pick Up 5 Items (Wear Oxygen Mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1363.8896484375) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1363.8896484375) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1340.1134418279) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1340.1134418279) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',339.05207343363) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',339.05207343363) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134707
"Order 60 Part 2 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134708
"Accept Order 61 from Paleontologist"
1
134709
"Order 61 Part 1 - Item 1/5 is provided from Order acceptance"
1
134710
"Order 61 Part 1 - Pick Up Item 2/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2006.7814941406) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2006.7814941406) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-994.57254506172) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-994.57254506172) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',313.21947800986) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',313.21947800986) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134711
"Order 61 Part 1 - Pick Up Item 3/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2023.0689173544) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2023.0689173544) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1055.4343608238) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1055.4343608238) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',323.76481236067) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',323.76481236067) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134712
"Order 61 Part 1 - Pick Up Item 4/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1990.8465221912) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1990.8465221912) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1036.2203802362) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1036.2203802362) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',317.49379607515) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',317.49379607515) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134713
"Order 61 Part 1 - Pick Up Item 5/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1933.8920058362) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1933.8920058362) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1017.9210827818) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1017.9210827818) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',324.2771466807) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',324.2771466807) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134714
"Order 61 Part 2 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134715
"Go to Lake Knot City and head to Private Room to receive new emails"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134716
"read email: "[Test Order] Could You Please Go Look for My Cube?""
1
134717
"Collect Lost Cargo (Cube 5)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1130.4993360723) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1130.4993360723) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-703.94982611795) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-703.94982611795) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',639.1679672582) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',639.1679672582) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134718
"Deliver Lost Cargo to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134719
"Head to Heartman's Lab to Accept Order 62 (Inside His Office)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134720
"Order 62 Part 1 - Deliver to Chiral Relay"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2560.48546139061) --X1
writeDouble('[VehicleCoordinates]+8F8', -2560.48546139061) --X2
writeDouble('[VehicleCoordinates]+D0', -1977.87025744527) --Y1
writeDouble('[VehicleCoordinates]+900', -1977.87025744527) -- Y2
writeDouble('[VehicleCoordinates]+D8', 84.1606949204215) -- Z1
writeDouble('[VehicleCoordinates]+908', 84.1606949204215) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134721
"Order 62 Part 2 - Start of BT Area (you might have a codec conversation with Die Hard-Man going south)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2643.8103602042) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2643.8103602042) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-2037.6214886959) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-2037.6214886959) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',86.067092449843) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',86.067092449843) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134722
"Order 62 Part 2 - Next to BTs (they wont spawn until the heavy rain starts (let them drown you)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2692.4359165859) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2692.4359165859) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-2152.2680664063) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-2152.2680664063) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',82.956943402588) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',82.956943402588) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134723
"After letting BT's drown you, switch back to Player (Player Only)"
1
134724
"This takes you to Episode 9: Higgs"
1
134725
"(Player Only) Find a Way to Cross the Tar Belt - Cause Buildings to Spawn"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2688.777832)
writeFloat('[PlayerCoordinates]+84', -2322.387451)
writeFloat('[PlayerCoordinates]+88', 86.26888275)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134726
"Die Hard-Man may speak to you after you drop down to the next bulding (East)"
1
134727
"(Player Only) Find a Way to Cross the Tar Belt - Cause Last Buildings to Spawn"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2612.965576)
writeFloat('[PlayerCoordinates]+84', -2598.32251)
writeFloat('[PlayerCoordinates]+88', 87.41194916)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134728
"This takes you to Episode 9: Higgs"
1
134729
"(Player Only) At Waypoint"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2603.3293457031) -- X Coord
writeFloat('[PlayerCoordinates]+84',-2657.1179199219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',81.047027587891) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134730
"Episode 9: Higgs"
1
134731
"Switch to Player, Vehicle Unavailable"
1
134732
"Episode 10: Die Hard-Man"
1
134733
"(Player Only) Head for Lake Knot City - Cutscene 1 with Deadman (Head North)"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1871.51953125) -- X Coord
writeFloat('[PlayerCoordinates]+84',-601.76788330078) -- Y Coord
writeFloat('[PlayerCoordinates]+88',502.23913574219) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134734
"(Player Only) Head for Lake Knot City - Fabricate a Vehicle at Mountain Knot City"
0000FF
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134735
"Head for Lake Knot City - Cutscene 2 with Deadman (Head North)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1498.378607996) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1498.378607996) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1567.3170228949) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1567.3170228949) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',228.50161491453) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',228.50161491453) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134736
"Head for Lake Knot City - Cutscene 3 with Deadman (Head North)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2003.897608683) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2003.897608683) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1162.1830090736) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1162.1830090736) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',179.31779401161) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',179.31779401161) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134737
"read e-mail: "A Final Request for Pizza""
1
134738
"Head to First Prepper to Accept Order 66"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134739
"Order 66 - Deliver to Peter Englert"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1736.88663510808) --X1
writeDouble('[VehicleCoordinates]+8F8', 1736.88663510808) --X2
writeDouble('[VehicleCoordinates]+D0', 1964.92318763108) --Y1
writeDouble('[VehicleCoordinates]+900', 1964.92318763108) -- Y2
writeDouble('[VehicleCoordinates]+D8', 210.988873047901) -- Z1
writeDouble('[VehicleCoordinates]+908', 210.988873047901) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134740
"Head for Lake Knot City - Cutscene 4 with Deadman & Heartman (Head North)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2397.8491210938) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2397.8491210938) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1612.9895257228) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1612.9895257228) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',201.72630953822) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',201.72630953822) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134741
"Head for Lake Knot City - Head North for Cutscene & start Episode 11: Clifford Unger"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2462.7893377219) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2462.7893377219) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1742.4263916016) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1742.4263916016) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',214.39523363994) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',214.39523363994) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134742
"Episode 11-14"
1
134743
"Switch to Player, Vehicle Unavailable"
1
134744
"Episode 15: Tomorrow Is In Your Hands"
1
134745
"Fragile Jump to Distribution Center South of Lake Knot City and Accept Order 76"
1
134746
"read email: "[Recovery Request] [V] My Chip! Grab it Back from the Terrorists!""
1
134747
"Make sure to Fabricate a Non-Lethal Weapon"
1
134748
"Order 76 Part 1 - [V] Neutralize the terrorists in the Ruins (Entrance of Lower Area)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1191.9215091426) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1191.9215091426) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1673.6600345332) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1673.6600345332) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',200.03720083935) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',200.03720083935) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134749
"Order 76 Part 1 - [V] Neutralize the terrorists in the Ruins (Exit of Lower Area, On Top)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1232.9531102786) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1232.9471435547) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1772.5300219362) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1772.5277099609) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',204.92822890551) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',204.92764282227) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134750
"Order 76 Part 2 - [V] Recover the Chip from Ruined Shelter Private Locker"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1321.75479916266) --X1
writeDouble('[VehicleCoordinates]+8F8', 1321.75479916266) --X2
writeDouble('[VehicleCoordinates]+D0', 1781.333984375) --Y1
writeDouble('[VehicleCoordinates]+900', 1781.333984375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 199.04028204791) -- Z1
writeDouble('[VehicleCoordinates]+908', 199.04028204791) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134751
"Order 76 Part 3 - [V] Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134752
"read email: "Have You Been Getting Some Weird Emails?""
1
134753
"Fabricate a PCC Lv.2 and withdraw 800 metal to build a bridge and a ladder"
1
134754
"Cube 6 Part 1 - build a bridge at this location, 80m long (change bridge length) or just use last teleport"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',953.27382402204) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',953.27382402204) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1930.4464620124) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1930.4464620124) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',168.36879857169) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',168.36879857169) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134755
"Cube 6 Part 1 - place a ladder to the other side"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',974.59488555306) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',974.59488555306) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',2053.302734375) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',2053.302734375) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',169.79765753053) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',169.79765753053) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134756
"Cube 6 Part 1 - Pick-up Lost Cargo: Final Companion Cube (Cube 6)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',980.71048728789) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',980.71048728789) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',2115.9127919334) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',2115.9127919334) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',182.53725918219) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',182.53725918219) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134757
"Cube 6 Part 2 - Deliver to the Incinerator West of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -322.187921711329) --X1
writeDouble('[VehicleCoordinates]+8F8', -322.187921711329) --X2
writeDouble('[VehicleCoordinates]+D0', 2190.62475585938) --Y1
writeDouble('[VehicleCoordinates]+900', 2190.62475585938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 217.562371936685) -- Z1
writeDouble('[VehicleCoordinates]+908', 217.562371936685) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134758
"Director's Cut Episode Quests"
008000
1
134759
"Eastern Region"
1
134760
"Accept Order 77 from Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134761
"Note: I had to do standard missions from this location to get Order 77 to unlock in late-game"
0000FF
1
134762
"Order 77 - Outside Entrance of Ruined Factory"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',121.37438201904) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',121.37320160016) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',451.79611206055) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',451.80475753175) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',252.77070617676) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',252.76691818649) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134763
"Order 77 - Pick up item 4 items at Ruined Factory MULEs Postbox"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',237.79909310743) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',237.79909310743) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',545.98508044267) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',545.98508044267) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',306.73775150412) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',306.73775150412) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134764
"Order 77 - Deliver to Distribution Center West of Capital Knot City & Accept Order 78"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134765
"Order 78 - Outside of Ruined Factory - Switch Back to Player"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',237.79909310743) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',237.79909310743) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',545.98508044267) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',545.98508044267) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',306.73775150412) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',306.73775150412) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134766
"(Player Only) Order 78 - Open Control Panel #1 at Ruined Factory"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',277.41485595703) -- X Coord
writeFloat('[PlayerCoordinates]+84',519.83526611328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134767
"(Player Only) - Order 78 - Pick up 5 item from MULEs Postbox"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',341.39114379883) -- X Coord
writeFloat('[PlayerCoordinates]+84',517.20544433594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134768
"(Player Only) Order 78 - Teleport back to Vehicle"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',241.1863861084) -- X Coord
writeFloat('[PlayerCoordinates]+84',539.00946044922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',307.48614501953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134769
"Order 78 - Deliver to Distribution Center West of Capital Knot City & Accept Order 79"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134770
"Order 79 - Outside of Ruined Factory - Switch Back to Player"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',237.79909310743) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',237.79909310743) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',545.98508044267) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',545.98508044267) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',306.73775150412) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',306.73775150412) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134771
"(Player Only) Order 79 - Open Control Panel #2 at Ruined Factory and Neutralize all Targets"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',341.39114379883) -- X Coord
writeFloat('[PlayerCoordinates]+84',517.20544433594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134772
"(Player Only) Order 79 - Open Control Panel #3 at Ruined Factory"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',370.11755371094) -- X Coord
writeFloat('[PlayerCoordinates]+84',582.50012207031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.35571289063) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134773
"(Player Only) Order 79 - Deliver items to Ruined Factory Terminal"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',343.82635498047) -- X Coord
writeFloat('[PlayerCoordinates]+84',592.18804931641) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.88571166992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134774
"(Player Only) Head up ladder for a cutscene"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',358.80374145508) -- X Coord
writeFloat('[PlayerCoordinates]+84',583.99438476563) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.38488769531) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134775
"(Player Only) Teleport back to Vehicle"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',241.1863861084) -- X Coord
writeFloat('[PlayerCoordinates]+84',539.00946044922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',307.48614501953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134776
"Central Region"
1
134777
"Accept Order 80 from Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134778
"Order 80 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134779
"Accept Order 81 from Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134780
"Order 81 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134781
"Accept Order 82 from Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134782
"Order 82 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134783
"Accept Order 83 from Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134784
"Order 83 - Near Rescue Area (Conversation moving east)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2123.5480957031) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2123.5480957031) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-696.08278957658) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-696.08278957658) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',184.96894408373) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',184.96894408373) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134785
"Order 83 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134786
"Order 84 - Move forward for a chat to be told about Order 84, then go accept"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1227.6452703404) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1227.6452703404) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',282.13054291528) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',282.13054291528) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',361.36755704518) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',361.36755704518) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134787
"Order 84 - Head east to rescue porter"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-879.39170779069) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-879.39170779069) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',453.41589220444) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',453.41589220444) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',465.86482045098) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',465.86482045098) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134788
"Order 84 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134789
"After turning in Order 82, Die-Hardman should tell you about Order 85, accept"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134790
"Order 85 - Head south (up hill) to rescue porter+cutscene"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2132.7560583943) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2132.7560583943) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-302.48597388589) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-302.48597388589) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',522.13353657688) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',522.13353657688) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134791
"Order 85 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134792
"Standard Orders"
1
134793
"Player"
1
134794
"Eastern Region"
1
134795
"From Capital Knot City"
1
134796
"Teleport To: Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134797
"Standard Order 100, 101, 102 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134798
"Standard Order 103, 104 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134799
"Standard Order 105, 106 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134800
"Standard Order 107, 108 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134801
"Standard Order 109 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 101.4508591)
writeFloat('[PlayerCoordinates]+84', 539.0170288)
writeFloat('[PlayerCoordinates]+88', 207.0962372)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134802
"Standard Order 110, 111 - Deliver to Musician"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -980.53302)
writeFloat('[PlayerCoordinates]+84', -120.1126404)
writeFloat('[PlayerCoordinates]+88', 184.5494537)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134803
"From Waystation West of Capital Knot City"
1
134804
"Teleport to: Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134805
"Standard Order 112, 113 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134806
"Standard Order 114 - Pick Up 8 Items (East Side of River)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',538.74273681641) -- X Coord
writeFloat('[PlayerCoordinates]+84',1297.1956787109) -- Y Coord
writeFloat('[PlayerCoordinates]+88',134.73930358887) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134807
"Standard Order 114 - West Side of River"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',533.18469238281) -- X Coord
writeFloat('[PlayerCoordinates]+84',1246.1390380859) -- Y Coord
writeFloat('[PlayerCoordinates]+88',135.1227722168) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134808
"Standard Order 114 - West Side of River, farther South"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',529.01019287109) -- X Coord
writeFloat('[PlayerCoordinates]+84',1213.1834716797) -- Y Coord
writeFloat('[PlayerCoordinates]+88',134.92193603516) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134809
"Standard Order 114 - East Side of River, farther South"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',514.56976318359) -- X Coord
writeFloat('[PlayerCoordinates]+84',1217.2783203125) -- Y Coord
writeFloat('[PlayerCoordinates]+88',134.75148010254) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134810
"Notes: Items Qty7 of 3.0kg, Qty1 of 68.0kg"
1
134811
"Notes: They are floating down the river"
1
134812
"Standard Order 115, 116, 117, 118 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134813
"Standard Order 119, 120 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134814
"Standard Order 121 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134815
"Standard Order 122, 123, 124 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 101.4508591)
writeFloat('[PlayerCoordinates]+84', 539.0170288)
writeFloat('[PlayerCoordinates]+88', 207.0962372)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134816
"From Distribution Center West of Capital Knot City"
1
134817
"Teleport to: Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134818
"Standard Order 125, 126 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134819
"Standard Order 127 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134820
"Standard Order 128 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 347.7147217)
writeFloat('[PlayerCoordinates]+84', 806.9052734)
writeFloat('[PlayerCoordinates]+88', 164.5243073)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134821
"Standard Order 128 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134822
"Standard Order 129 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -622.9569702)
writeFloat('[PlayerCoordinates]+84', -107.1672058)
writeFloat('[PlayerCoordinates]+88', 223.7973175)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134823
"Standard Order 130 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134824
"Standard Order 131 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134825
"Standard Order 132 - Deliver to Musician"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -980.53302)
writeFloat('[PlayerCoordinates]+84', -120.1126404)
writeFloat('[PlayerCoordinates]+88', 184.5494537)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134826
"From Wind Farm"
1
134827
"Teleport to: Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134828
"Standard Order 133, 134, 135, 136, 137 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134829
"Standard Order 138, 139 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134830
"Standard Order 140, 141, 142 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134831
"Standard Order 143 - Item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1376.4312744141) -- X Coord
writeFloat('[PlayerCoordinates]+84',467.20587158203) -- Y Coord
writeFloat('[PlayerCoordinates]+88',201.23971557617) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134832
"Standard Order 143 - Item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1326.1235351563) -- X Coord
writeFloat('[PlayerCoordinates]+84',559.01721191406) -- Y Coord
writeFloat('[PlayerCoordinates]+88',186.09246826172) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134833
"Standard Order 143 - Item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1360.9792480469) -- X Coord
writeFloat('[PlayerCoordinates]+84',638.2197265625) -- Y Coord
writeFloat('[PlayerCoordinates]+88',223.08700561523) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134834
"Standard Order 144 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 101.4508591)
writeFloat('[PlayerCoordinates]+84', 539.0170288)
writeFloat('[PlayerCoordinates]+88', 207.0962372)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134835
"Standard Order 600 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134836
"From Port Knot City"
1
134837
"Teleport to: Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134838
"Standard Order 145, 146 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134839
"Standard Order 147, 148 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134840
"Standard Order 149, 150 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134841
"Standard Order 151, 152 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134842
"Standard Order 153 - Pick up 3 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -622.9569702)
writeFloat('[PlayerCoordinates]+84', -107.1672058)
writeFloat('[PlayerCoordinates]+88', 223.7973175)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134843
"Standard Order 154, 155 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 101.4508591)
writeFloat('[PlayerCoordinates]+84', 539.0170288)
writeFloat('[PlayerCoordinates]+88', 207.0962372)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134844
"From Luden's Fan"
1
134845
"Teleport to: Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 101.4508591)
writeFloat('[PlayerCoordinates]+84', 539.0170288)
writeFloat('[PlayerCoordinates]+88', 207.0962372)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134846
"Standard Order 156 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134847
"Standard Order 157 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134848
"Standard Order 158 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134849
"Standard Order 159 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1490.662476)
writeFloat('[PlayerCoordinates]+84', 656.2297974)
writeFloat('[PlayerCoordinates]+88', 205.5592499)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134850
"Standard Order 160 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134851
"Standard Order 161 - Pick up [2] items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 347.7147217)
writeFloat('[PlayerCoordinates]+84', 806.9052734)
writeFloat('[PlayerCoordinates]+88', 164.5243073)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134852
"From Musician"
1
134853
"Teleport to: Musician"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -980.53302)
writeFloat('[PlayerCoordinates]+84', -120.1126404)
writeFloat('[PlayerCoordinates]+88', 184.5494537)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134854
"Standard Order 162, 163, 164, 165 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1432.995117)
writeFloat('[PlayerCoordinates]+84', 701.8141479)
writeFloat('[PlayerCoordinates]+88', 137.3023224)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134855
"Standard Order 166, 167 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 313.767334)
writeFloat('[PlayerCoordinates]+84', 1160.296875)
writeFloat('[PlayerCoordinates]+88', 162.9519653)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134856
"Standard Order 168, 169, 170, 171 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -438.5249329)
writeFloat('[PlayerCoordinates]+84', 266.2165527)
writeFloat('[PlayerCoordinates]+88', 137.3740692)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134857
"Standard Order 172 - Item 1/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-782.70141601563) -- X Coord
writeFloat('[PlayerCoordinates]+84',1.7735116481781) -- Y Coord
writeFloat('[PlayerCoordinates]+88',156.1656036377) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134858
"Standard Order 172 - Item 2/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-879.19934082031) -- X Coord
writeFloat('[PlayerCoordinates]+84',0.8140344619751) -- Y Coord
writeFloat('[PlayerCoordinates]+88',155.41006469727) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134859
"Standard Order 601 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1986.126221)
writeFloat('[PlayerCoordinates]+84', -480.7706299)
writeFloat('[PlayerCoordinates]+88', 139.4775085)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134860
"Central Region"
1
134861
"From Engineer"
1
134862
"Teleport to: Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134863
"Standard Order 173 - Pick up 1/4 and 2/4 item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.813354)
writeFloat('[PlayerCoordinates]+84', 1064.050903)
writeFloat('[PlayerCoordinates]+88', 176.1360779)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134864
"Standard Order 173 - Pick up 3/4 and 4/4 item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1674.913452)
writeFloat('[PlayerCoordinates]+84', 960.6556396)
writeFloat('[PlayerCoordinates]+88', 175.3177338)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134865
"Standard Order 174 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134866
"Standard Order 175, 176 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134867
"Standard Order 177 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134868
"Standard Order 178 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134869
"Standard Order 179, 180 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134870
"Standard Order 181, 182 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134871
"Standard Order 183, 184 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134872
"Standard Order 185 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134873
"Standard Order 186, 187 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134874
"Standard Order 602 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134875
"From Elder"
1
134876
"Teleport to: Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134877
"Standard Order 188, 189 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134878
"Standard Order 190 - Pick up 1-3/8 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1519.881714)
writeFloat('[PlayerCoordinates]+84', 992.4251099)
writeFloat('[PlayerCoordinates]+88', 173.4361572)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134879
"Standard Order 190 - Pick up 4-5/8 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1674.913452)
writeFloat('[PlayerCoordinates]+84', 960.6556396)
writeFloat('[PlayerCoordinates]+88', 175.3177338)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134880
"Standard Order 190 - Pick up 6-8/8 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.813354)
writeFloat('[PlayerCoordinates]+84', 1064.050903)
writeFloat('[PlayerCoordinates]+88', 176.1360779)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134881
"Standard Order 191, 192 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134882
"Standard Order 193, 194 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134883
"Standard Order 195, 196 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134884
"Standard Order 197 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134885
"Standard Order 198 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134886
"Standard Order 603 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134887
"From Craftsman"
1
134888
"Teleport to: Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134889
"Standard Order 199, 200 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134890
"Standard Order 201 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134891
"Standard Order 202 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 539.6925049)
writeFloat('[PlayerCoordinates]+84', 885.2458496)
writeFloat('[PlayerCoordinates]+88', 174.2861328)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134892
"Standard Order 202 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134893
"Standard Order 203 - Item 1/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1277.2947998047) -- X Coord
writeFloat('[PlayerCoordinates]+84',1650.4176025391) -- Y Coord
writeFloat('[PlayerCoordinates]+88',199.81755065918) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134894
"Standard Order 203 - Item 2/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1245.4796142578) -- X Coord
writeFloat('[PlayerCoordinates]+84',1661.7210693359) -- Y Coord
writeFloat('[PlayerCoordinates]+88',196.87916564941) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134895
"Standard Order 203 - Item 3/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1353.1273193359) -- X Coord
writeFloat('[PlayerCoordinates]+84',1842.2951660156) -- Y Coord
writeFloat('[PlayerCoordinates]+88',217.91390991211) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134896
"Standard Order 203 - Item 4/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1326.4187011719) -- X Coord
writeFloat('[PlayerCoordinates]+84',1640.7020263672) -- Y Coord
writeFloat('[PlayerCoordinates]+88',234.05717468262) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134897
"Standard Order 203 - Item 5/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1315.0336914063) -- X Coord
writeFloat('[PlayerCoordinates]+84',1667.111328125) -- Y Coord
writeFloat('[PlayerCoordinates]+88',208.73355102539) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134898
"Standard Order 203 - Item 6/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1366.455078125) -- X Coord
writeFloat('[PlayerCoordinates]+84',1719.1708984375) -- Y Coord
writeFloat('[PlayerCoordinates]+88',201.0471496582) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134899
"Standard Order 203 - Item 7/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1218.3952636719) -- X Coord
writeFloat('[PlayerCoordinates]+84',1691.8856201172) -- Y Coord
writeFloat('[PlayerCoordinates]+88',194.67463684082) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134900
"Standard Order 203 - Item 8/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1232.1402587891) -- X Coord
writeFloat('[PlayerCoordinates]+84',1757.1409912109) -- Y Coord
writeFloat('[PlayerCoordinates]+88',197.26246643066) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134901
"Standard Order 203 - Item 9/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1280.0035400391) -- X Coord
writeFloat('[PlayerCoordinates]+84',1821.4002685547) -- Y Coord
writeFloat('[PlayerCoordinates]+88',196.72442626953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134902
"Standard Order 203 - Item 10/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1329.1955566406) -- X Coord
writeFloat('[PlayerCoordinates]+84',1761.7088623047) -- Y Coord
writeFloat('[PlayerCoordinates]+88',204.50823974609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134903
"Standard Order 203 - Item 11/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1291.0003662109) -- X Coord
writeFloat('[PlayerCoordinates]+84',1752.4949951172) -- Y Coord
writeFloat('[PlayerCoordinates]+88',195.1579284668) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134904
"Standard Order 203 - Item 12/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1305.8538818359) -- X Coord
writeFloat('[PlayerCoordinates]+84',1717.9089355469) -- Y Coord
writeFloat('[PlayerCoordinates]+88',197.96995544434) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134905
"Standard Order 204 - Pick up item"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1326.4937744141)
writeFloat('[PlayerCoordinates]+84', 1787.4482421875)
writeFloat('[PlayerCoordinates]+88', 200.16622924805)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134906
"Standard Order 205 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134907
"Standard Order 206 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134908
"Standard Order 207, 208 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134909
"Standard Order 209 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134910
"Standard Order 210, 211 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134911
"Standard Order 212 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134912
"Standard Order 213 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134913
"Standard Order 214, 215 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134914
"Standard Order 604 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134915
"From Timefall Farm"
1
134916
"Teleport to: Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134917
"Standard Order 216 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134918
"Standard Order 217, 218 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134919
"Standard Order 219 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134920
"Standard Order 220 - Pick up 2 of 5 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -47.38366318)
writeFloat('[PlayerCoordinates]+84', -1264.429321)
writeFloat('[PlayerCoordinates]+88', 117.9734192)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134921
"Standard Order 220 - Pick up 3 of 5 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 287.2895203)
writeFloat('[PlayerCoordinates]+84', -1231.669556)
writeFloat('[PlayerCoordinates]+88', 104.318367)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134922
"Standard Order 221 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134923
"Standard Order 222 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134924
"Standard Order 223 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134925
"Standard Order 224 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134926
"Standard Order 225 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134927
"Standard Order 226 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134928
"Standard Order 227, 228 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134929
"Standard Order 229 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134930
"Standard Order 230 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134931
"Standard Order 231 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134932
"Standard Order 605 - Pick up item 1/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',150.68518066406) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1891.2823486328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',104.58309173584) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134933
"Standard Order 605 - Pick up item 2/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',145.45516967773) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1905.6818847656) -- Y Coord
writeFloat('[PlayerCoordinates]+88',103.92874145508) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134934
"Standard Order 605 - Pick up item 3/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',148.05787658691) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1975.1652832031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',99.673324584961) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134935
"Standard Order 605 - Pick up item 4/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',47.368530273438) -- X Coord
writeFloat('[PlayerCoordinates]+84',-2018.7274169922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',94.080978393555) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134936
"Standard Order 605 - Pick up item 5/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',172.37208557129) -- X Coord
writeFloat('[PlayerCoordinates]+84',-2081.0056152344) -- Y Coord
writeFloat('[PlayerCoordinates]+88',103.05184936523) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134937
"Standard Order 605 - Pick up item 6/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',206.98767089844) -- X Coord
writeFloat('[PlayerCoordinates]+84',-2005.3509521484) -- Y Coord
writeFloat('[PlayerCoordinates]+88',118.95756530762) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134938
"Standard Order 606 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134939
"Standard Order 607 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134940
"Standard Order 608 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134941
"From Junk Dealer"
1
134942
"Teleport to: Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134943
"Standard Order 232 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134944
"Standard Order 233, 234 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134945
"Standard Order 235 - Pick up 1/6 & 4/6 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1450.897339)
writeFloat('[PlayerCoordinates]+84', 210.0477753)
writeFloat('[PlayerCoordinates]+88', 134.6021881)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134946
"Standard Order 235 - Pick up 2/6 & 3/6 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1416.170044)
writeFloat('[PlayerCoordinates]+84', 33.30061722)
writeFloat('[PlayerCoordinates]+88', 130.302597)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134947
"Standard Order 235 - Pick up 5/6 & 6/6 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1322.740356)
writeFloat('[PlayerCoordinates]+84', -104.4131546)
writeFloat('[PlayerCoordinates]+88', 134.1850281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134948
"Standard Order 236 - pick up 1/5 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1033.3890380859) -- X Coord
writeFloat('[PlayerCoordinates]+84',-286.65512084961) -- Y Coord
writeFloat('[PlayerCoordinates]+88',113.88230895996) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134949
"Standard Order 236 - pick up 4/5 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1023.3867797852) -- X Coord
writeFloat('[PlayerCoordinates]+84',-284.3401184082) -- Y Coord
writeFloat('[PlayerCoordinates]+88',128.44570922852) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134950
"Standard Order 236 - pick up 3/5 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1004.3600463867) -- X Coord
writeFloat('[PlayerCoordinates]+84',-311.05718994141) -- Y Coord
writeFloat('[PlayerCoordinates]+88',111.22936248779) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134951
"Standard Order 236 - pick up 4/5 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',988.54357910156) -- X Coord
writeFloat('[PlayerCoordinates]+84',-312.82986450195) -- Y Coord
writeFloat('[PlayerCoordinates]+88',122.80693817139) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134952
"Standard Order 236 - pick up 5/5 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',982.66955566406) -- X Coord
writeFloat('[PlayerCoordinates]+84',-320.69876098633) -- Y Coord
writeFloat('[PlayerCoordinates]+88',116.83218383789) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134953
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1188.9783935547) -- X Coord
writeFloat('[PlayerCoordinates]+84',-652.0498046875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',141.46401977539) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134954
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1279.5874023438) -- X Coord
writeFloat('[PlayerCoordinates]+84',-740.49169921875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',142.1597442627) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134955
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1232.4254150391) -- X Coord
writeFloat('[PlayerCoordinates]+84',-609.76129150391) -- Y Coord
writeFloat('[PlayerCoordinates]+88',138.11064147949) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134956
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1215.8090820313) -- X Coord
writeFloat('[PlayerCoordinates]+84',-619.72302246094) -- Y Coord
writeFloat('[PlayerCoordinates]+88',139.26835632324) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134957
"Standard Order 237 - Pick up item - 20/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1242.8618164063) -- X Coord
writeFloat('[PlayerCoordinates]+84',-676.93310546875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',144.10029602051) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134958
"Standard Order 237 - Pick up item - 20/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1212.8497314453) -- X Coord
writeFloat('[PlayerCoordinates]+84',-657.69348144531) -- Y Coord
writeFloat('[PlayerCoordinates]+88',144.54275512695) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134959
"Standard Order 237 - Pick up item - 30/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1171.5255126953) -- X Coord
writeFloat('[PlayerCoordinates]+84',-578.49353027344) -- Y Coord
writeFloat('[PlayerCoordinates]+88',142.99797058105) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134960
"Standard Order 238, 239, 240, 241 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134961
"Standard Order 242 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134962
"Standard Order 243 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134963
"Standard Order 244 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134964
"Standard Order 245 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134965
"Standard Order 246 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134966
"Standard Order 247 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134967
"Standard Order 248, 249, 250 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134968
"Standard Order 251, 252 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134969
"Standard Order 253, 254 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134970
"Standard Order 609 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134971
"From Chiral Artist's Studio"
1
134972
"Teleport to: Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134973
"Standard Order 255, 256, 257 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134974
"Standard Order 258 - item 1/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1442.1732177734) -- X Coord
writeFloat('[PlayerCoordinates]+84',-846.88592529297) -- Y Coord
writeFloat('[PlayerCoordinates]+88',127.15309143066) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134975
"Standard Order 258 - item 2/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1496.8579101563) -- X Coord
writeFloat('[PlayerCoordinates]+84',-913.66082763672) -- Y Coord
writeFloat('[PlayerCoordinates]+88',126.61714935303) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134976
"Standard Order 258 - item 3/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1496.4111328125) -- X Coord
writeFloat('[PlayerCoordinates]+84',-965.77868652344) -- Y Coord
writeFloat('[PlayerCoordinates]+88',126.2717666626) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134977
"Standard Order 258 - item 4/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1457.5051269531) -- X Coord
writeFloat('[PlayerCoordinates]+84',-858.28894042969) -- Y Coord
writeFloat('[PlayerCoordinates]+88',127.80170440674) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134978
"Standard Order 258 - item 5/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1492.73046875) -- X Coord
writeFloat('[PlayerCoordinates]+84',-903.89691162109) -- Y Coord
writeFloat('[PlayerCoordinates]+88',126.84494781494) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134979
"Standard Order 258 - item 6/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1493.9774169922) -- X Coord
writeFloat('[PlayerCoordinates]+84',-958.54907226563) -- Y Coord
writeFloat('[PlayerCoordinates]+88',126.92110443115) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134980
"Standard Order 259 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134981
"Standard Order 260 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134982
"Standard Order 261 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134983
"Standard Order 262 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134984
"Standard Order 263, 264 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134985
"Standard Order 265 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134986
"Standard Order 266 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134987
"Standard Order 610 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134988
"Standard Order 611 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134989
"From Waystation North of Mountain Knot City"
1
134990
"Teleport to: Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134991
"Standard Order 267, 268 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134992
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-102.48191833496) -- X Coord
writeFloat('[PlayerCoordinates]+84',1738.4359130859) -- Y Coord
writeFloat('[PlayerCoordinates]+88',323.17526245117) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134993
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-107.51142883301) -- X Coord
writeFloat('[PlayerCoordinates]+84',1691.0695800781) -- Y Coord
writeFloat('[PlayerCoordinates]+88',332.23928833008) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134994
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-129.83587646484) -- X Coord
writeFloat('[PlayerCoordinates]+84',1654.0974121094) -- Y Coord
writeFloat('[PlayerCoordinates]+88',348.81433105469) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134995
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-166.93212890625) -- X Coord
writeFloat('[PlayerCoordinates]+84',1712.9616699219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',344.13131713867) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
134996
"Standard Order 270, 271 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134997
"Standard Order 272, 273 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134998
"Standard Order 274, 275 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
134999
"Standard Order 276, 277 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135000
"Standard Order 278 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135001
"Standard Order 279 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135002
"Standard Order 280, 281, 282 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135003
"Standard Order 283 - Pick up 1/4 & 2/4 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -758.4589233)
writeFloat('[PlayerCoordinates]+84', 1811.8302)
writeFloat('[PlayerCoordinates]+88', 224.3075867)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135004
"Standard Order 283 - Pick up 3/4 & 4/4 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -852.6716919)
writeFloat('[PlayerCoordinates]+84', 1918.503418)
writeFloat('[PlayerCoordinates]+88', 224.05896)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135005
"Standard Order 284 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135006
"Standard Order 612 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135007
"From Roboticist"
1
135008
"Teleport to: Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135009
"Standard Order 285, 286 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135010
"Standard Order 287 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2441.5659179688)
writeFloat('[PlayerCoordinates]+84', 1291.0874023438)
writeFloat('[PlayerCoordinates]+88', 251.06520080566)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135011
"Standard Order 288, 289 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135012
"Standard Order 290 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135013
"Standard Order 291 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135014
"Standard Order 613 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135015
"Standard Order 614 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135016
"Standard Order 615 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135017
"Standard Order 616 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135018
"From Mountaineer"
1
135019
"Teleport to: Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135020
"Standard Order 292 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135021
"Standard Order 293 - item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1063.4508056641) -- X Coord
writeFloat('[PlayerCoordinates]+84',807.49243164063) -- Y Coord
writeFloat('[PlayerCoordinates]+88',474.11560058594) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135022
"Standard Order 293 - item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1148.1690673828) -- X Coord
writeFloat('[PlayerCoordinates]+84',760.69793701172) -- Y Coord
writeFloat('[PlayerCoordinates]+88',423.42977905273) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135023
"Standard Order 293 - item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1075.4835205078) -- X Coord
writeFloat('[PlayerCoordinates]+84',711.63800048828) -- Y Coord
writeFloat('[PlayerCoordinates]+88',421.92651367188) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135024
"Standard Order 293 - item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1087.7349853516) -- X Coord
writeFloat('[PlayerCoordinates]+84',756.84539794922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',429.26803588867) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135025
"Standard Order 294 - 2.5/50.5kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-839.68621826172) -- X Coord
writeFloat('[PlayerCoordinates]+84',1381.8358154297) -- Y Coord
writeFloat('[PlayerCoordinates]+88',507.98223876953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135026
"Standard Order 294 - 16.0/50.5kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-886.73620605469) -- X Coord
writeFloat('[PlayerCoordinates]+84',1547.2239990234) -- Y Coord
writeFloat('[PlayerCoordinates]+88',443.43649291992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135027
"Standard Order 294 - 32.0/50.5kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-869.11975097656) -- X Coord
writeFloat('[PlayerCoordinates]+84',1477.3526611328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',470.50717163086) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135028
"Standard Order 295 - Pick up 2 items from Doctor private locker"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135029
"Standard Order 296 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135030
"Standard Order 297 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135031
"Standard Order 298 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135032
"Standard Order 617 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135033
"Standard Order 618 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135034
"Standard Order 619 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135035
"From Photographer"
1
135036
"Teleport to: Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135037
"Standard Order 299 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135038
"Standard Order 300 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135039
"Standard Order 301 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135040
"Standard Order 302 - pick up item 1/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2358.5241699219) -- X Coord
writeFloat('[PlayerCoordinates]+84',935.01617431641) -- Y Coord
writeFloat('[PlayerCoordinates]+88',213.15675354004) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135041
"Standard Order 302 - pick up item 2/2 (floating down river)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2310.4409179688) -- X Coord
writeFloat('[PlayerCoordinates]+84',1010.5553588867) -- Y Coord
writeFloat('[PlayerCoordinates]+88',217.93942260742) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135042
"Standard Order 303 - Pick up item 30.0/90.0 & 15.0/90.0 from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1550.640991)
writeFloat('[PlayerCoordinates]+84', 1282.209595)
writeFloat('[PlayerCoordinates]+88', 241.9241943)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135043
"Standard Order 303 - Pick up item 30.0/90.0 & 15.0/90.0 from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1695.691895)
writeFloat('[PlayerCoordinates]+84', 1088.499268)
writeFloat('[PlayerCoordinates]+88', 220.418869)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135044
"Standard Order 304 - pick up item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1851.8474121094) -- X Coord
writeFloat('[PlayerCoordinates]+84',571.76635742188) -- Y Coord
writeFloat('[PlayerCoordinates]+88',249.16372680664) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135045
"Standard Order 304 - pick up item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1890.5684814453) -- X Coord
writeFloat('[PlayerCoordinates]+84',690.3701171875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',237.01852416992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135046
"Standard Order 304 - pick up item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1773.9481201172) -- X Coord
writeFloat('[PlayerCoordinates]+84',760.59051513672) -- Y Coord
writeFloat('[PlayerCoordinates]+88',233.60011291504) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135047
"Standard Order 305 - pick up item 1/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2554.65234375) -- X Coord
writeFloat('[PlayerCoordinates]+84',705.23272705078) -- Y Coord
writeFloat('[PlayerCoordinates]+88',214.40057373047) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135048
"Standard Order 305 - pick up item 2/5 (floating down river)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2544.1823730469) -- X Coord
writeFloat('[PlayerCoordinates]+84',778.39416503906) -- Y Coord
writeFloat('[PlayerCoordinates]+88',209.16925048828) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135049
"Standard Order 305 - pick up item 3/5 (floating down river)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2446.43359375) -- X Coord
writeFloat('[PlayerCoordinates]+84',732.92590332031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',218.04811096191) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135050
"Standard Order 305 - pick up item 4/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2458.7358398438) -- X Coord
writeFloat('[PlayerCoordinates]+84',805.76281738281) -- Y Coord
writeFloat('[PlayerCoordinates]+88',209.46855163574) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135051
"Standard Order 305 - pick up item 5/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2588.0266113281) -- X Coord
writeFloat('[PlayerCoordinates]+84',771.5537109375) -- Y Coord
writeFloat('[PlayerCoordinates]+88',208.85223388672) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135052
"Standard Order 306 - Pick up item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1550.640991)
writeFloat('[PlayerCoordinates]+84', 1282.209595)
writeFloat('[PlayerCoordinates]+88', 241.9241943)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135053
"Standard Order 307 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135054
"Standard Order 308 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135055
"Standard Order 309 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135056
"Standard Order 310, 311 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135057
"From Spiritualist"
1
135058
"Teleport to: Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135059
"Standard Order 312 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135060
"Standard Order 313 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135061
"Standard Order 314 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135062
"Standard Order 315 - item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',369.35089111328) -- X Coord
writeFloat('[PlayerCoordinates]+84',-563.03277587891) -- Y Coord
writeFloat('[PlayerCoordinates]+88',183.21939086914) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135063
"Standard Order 315 - item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',417.47357177734) -- X Coord
writeFloat('[PlayerCoordinates]+84',-604.05236816406) -- Y Coord
writeFloat('[PlayerCoordinates]+88',159.4059753418) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135064
"Standard Order 315 - item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',352.40997314453) -- X Coord
writeFloat('[PlayerCoordinates]+84',-598.94934082031) -- Y Coord
writeFloat('[PlayerCoordinates]+88',175.6197052002) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135065
"Standard Order 316 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135066
"Standard Order 317, 318 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135067
"Standard Order 319 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135068
"Standard Order 320 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135069
"Standard Order 321 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135070
"Standard Order 620 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135071
"From Doctor"
1
135072
"Teleport to: Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135073
"Standard Order 322 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135074
"Standard Order 323, 324 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135075
"Standard Order 325 - Grab 2 out of 3 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1550.640991)
writeFloat('[PlayerCoordinates]+84', 1282.209595)
writeFloat('[PlayerCoordinates]+88', 241.9241943)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135076
"Standard Order 325 - Grab 1 out of 3 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1695.691895)
writeFloat('[PlayerCoordinates]+84', 1088.499268)
writeFloat('[PlayerCoordinates]+88', 220.418869)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135077
"Standard Order 326 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135078
"Standard Order 327 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2441.5659179688)
writeFloat('[PlayerCoordinates]+84', 1291.0874023438)
writeFloat('[PlayerCoordinates]+88', 251.06520080566)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135079
"Standard Order 328 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135080
"Standard Order 329, 330 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135081
"Standard Order 331, 332 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135082
"Standard Order 333 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135083
"From Geologist"
1
135084
"Teleport to: Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135085
"Standard Order 334 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135086
"Standard Order 335, 336 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135087
"Standard Order 337 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135088
"Standard Order 338 - item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-708.4169921875) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1155.9125976563) -- Y Coord
writeFloat('[PlayerCoordinates]+88',393.92913818359) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135089
"Standard Order 338 - item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-702.3134765625) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1187.7216796875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',370.35589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135090
"Standard Order 338 - item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-681.0361328125) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1126.8367919922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',409.90438842773) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135091
"Standard Order 338 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135092
"Standard Order 339 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135093
"Standard Order 340, 341 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135094
"Standard Order 342 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135095
"Standard Order 343 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135096
"Standard Order 344 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135097
"Standard Order 621 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135098
"From Paleontologist"
1
135099
"Teleport to: Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135100
"Standard Order 345, 346 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135101
"Standard Order 347 - Pick up item 1/2 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1888.633545)
writeFloat('[PlayerCoordinates]+84', -1423.368896)
writeFloat('[PlayerCoordinates]+88', 317.8652344)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135102
"Standard Order 347 - Pick up item 2/2 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2034.582642)
writeFloat('[PlayerCoordinates]+84', -1499.935303)
writeFloat('[PlayerCoordinates]+88', 287.5764771)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135103
"Standard Order 348 - item 1/5 (need oxygen mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1369.9002685547) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1347.1613769531) -- Y Coord
writeFloat('[PlayerCoordinates]+88',340.50689697266) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135104
"Standard Order 348 - item 2/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1351.9140625) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1337.7009277344) -- Y Coord
writeFloat('[PlayerCoordinates]+88',343.79858398438) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135105
"Standard Order 348 - item 3/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1378.666015625) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1340.9321289063) -- Y Coord
writeFloat('[PlayerCoordinates]+88',341.27722167969) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135106
"Standard Order 348 - item 4/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1359.6401367188) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1336.7027587891) -- Y Coord
writeFloat('[PlayerCoordinates]+88',340.9944152832) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135107
"Standard Order 348 - item 5/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1358.9368896484) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1336.9677734375) -- Y Coord
writeFloat('[PlayerCoordinates]+88',340.99661254883) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135108
"Standard Order 349 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135109
"Standard Order 350, 351 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135110
"Standard Order 352 - item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2011.4782714844) -- X Coord
writeFloat('[PlayerCoordinates]+84',-981.90301513672) -- Y Coord
writeFloat('[PlayerCoordinates]+88',315.69424438477) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135111
"Standard Order 352 - item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-2027.5375976563) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1061.5262451172) -- Y Coord
writeFloat('[PlayerCoordinates]+88',322.40969848633) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135112
"Standard Order 352 - item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1928.0103759766) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1009.0362548828) -- Y Coord
writeFloat('[PlayerCoordinates]+88',328.04840087891) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135113
"Standard Order 352 - item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1987.3453369141) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1045.4931640625) -- Y Coord
writeFloat('[PlayerCoordinates]+88',317.96395874023) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135114
"Standard Order 352 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135115
"Standard Order 353 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135116
"Standard Order 354 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135117
"Standard Order 355 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135118
"Standard Order 356, 357 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135119
"From Veteran Porter"
1
135120
"Teleport to: Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135121
"Standard Order 358, 359 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135122
"Standard Order 360, 361 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135123
"Standard Order 362 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135124
"Standard Order 363 - Pick up item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',6.908561706543) -- X Coord
writeFloat('[PlayerCoordinates]+84',-928.75341796875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',129.24418640137) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135125
"Standard Order 363 - Pick up item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',24.503883361816) -- X Coord
writeFloat('[PlayerCoordinates]+84',-977.44952392578) -- Y Coord
writeFloat('[PlayerCoordinates]+88',127.62291717529) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135126
"Standard Order 363 - Pick up item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',31.133443832397) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1011.7098388672) -- Y Coord
writeFloat('[PlayerCoordinates]+88',125.46244812012) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135127
"Standard Order 363 - Pick up item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-34.409656524658) -- X Coord
writeFloat('[PlayerCoordinates]+84',-895.20886230469) -- Y Coord
writeFloat('[PlayerCoordinates]+88',137.89083862305) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135128
"Standard Order 364 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135129
"Standard Order 365 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135130
"Standard Order 622 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135131
"Standard Order 623 - Pick up item 1/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 287.2895203)
writeFloat('[PlayerCoordinates]+84', -1231.669556)
writeFloat('[PlayerCoordinates]+88', 104.318367)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135132
"Standard Order 623 - Pick up item 2/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 212.8048248)
writeFloat('[PlayerCoordinates]+84', -1321.593384)
writeFloat('[PlayerCoordinates]+88', 111.9862213)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135133
"Standard Order 623 - Pick up item 3/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -47.38366318)
writeFloat('[PlayerCoordinates]+84', -1264.429321)
writeFloat('[PlayerCoordinates]+88', 117.9734192)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135134
"Standard Order 624 - Pick up 3 items from Geologist private locker"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135135
"Standard Order 625 - Pick up 3 items from Mountain Knot City private locker"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135136
"Standard Order 626 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135137
"From Evo-Devo Biologist"
1
135138
"Teleport to: Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135139
"Standard Order 366 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135140
"Standard Order 367 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135141
"Standard Order 368 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135142
"Standard Order 369, 370 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135143
"Standard Order 371 - Pick up 1 out of 2 items from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1973.025146)
writeFloat('[PlayerCoordinates]+84', -1232.20105)
writeFloat('[PlayerCoordinates]+88', 319.3590088)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135144
"Standard Order 371 - Pick up 1 out of 2 items from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1888.633545)
writeFloat('[PlayerCoordinates]+84', -1423.368896)
writeFloat('[PlayerCoordinates]+88', 317.8652344)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135145
"Standard Order 372 - Pick up item 1/3 (requires oxygen mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1374.3210449219) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1346.3881835938) -- Y Coord
writeFloat('[PlayerCoordinates]+88',339.97006225586) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135146
"Standard Order 372 - Pick up item 2/3 (requires oxygen mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1357.28515625) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1333.0690917969) -- Y Coord
writeFloat('[PlayerCoordinates]+88',344.47534179688) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135147
"Standard Order 372 - Pick up item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1390.7003173828) -- X Coord
writeFloat('[PlayerCoordinates]+84',-1354.7497558594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',353.81820678711) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135148
"Standard Order 373 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135149
"Standard Order 374 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135150
"Standard Order 375 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135151
"Standard Order 376 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135152
"Standard Order 627 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135153
"From Film Director"
1
135154
"Teleport to: Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135155
"Standard Order 378 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135156
"Standard Order 381 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135157
"Standard Order 377 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135158
"Standard Order 378 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135159
"Standard Order 379 - Pick up item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',595.52844238281) -- X Coord
writeFloat('[PlayerCoordinates]+84',-599.80908203125) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.11145019531) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135160
"Standard Order 379 - Pick up item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',523.78137207031) -- X Coord
writeFloat('[PlayerCoordinates]+84',-592.39337158203) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.62718200684) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135161
"Standard Order 379 - Pick up item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',575.7783203125) -- X Coord
writeFloat('[PlayerCoordinates]+84',-607.74694824219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.65968322754) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135162
"Standard Order 379 - Pick up item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',529.31451416016) -- X Coord
writeFloat('[PlayerCoordinates]+84',-605.53698730469) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.67492675781) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135163
"Standard Order 379 - Teleport Back to Vehicle (if you used my vehicle location)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',623.51251220703) -- X Coord
writeFloat('[PlayerCoordinates]+84',-601.41424560547) -- Y Coord
writeFloat('[PlayerCoordinates]+88',157.29495239258) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135164
"Standard Order 380 - Pick up item 1/4 (Requires Oxygen Mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2087.8728027344) -- X Coord
writeFloat('[PlayerCoordinates]+84',281.57427978516) -- Y Coord
writeFloat('[PlayerCoordinates]+88',161.23458862305) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135165
"Standard Order 380 - Pick up item 2/4 (Requires Oxygen Mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2136.7121582031) -- X Coord
writeFloat('[PlayerCoordinates]+84',290.2262878418) -- Y Coord
writeFloat('[PlayerCoordinates]+88',154.72618103027) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135166
"Standard Order 380 - Pick up item 3/4 (Requires Oxygen Mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2066.7980957031) -- X Coord
writeFloat('[PlayerCoordinates]+84',287.32989501953) -- Y Coord
writeFloat('[PlayerCoordinates]+88',154.25947570801) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135167
"Standard Order 380 - Pick up item 4/4 (Requires Oxygen Mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2121.6508789063) -- X Coord
writeFloat('[PlayerCoordinates]+84',298.55728149414) -- Y Coord
writeFloat('[PlayerCoordinates]+88',160.50199890137) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135168
"Standard Order 380 - Teleport Back to Vehicle (if you used my vehicle location)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2197.001953125) -- X Coord
writeFloat('[PlayerCoordinates]+84',296.94464111328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',175.28324890137) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135169
"Standard Order 381 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135170
"Standard Order 382 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135171
"Standard Order 383 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135172
"From Cosplayer"
1
135173
"Teleport to: Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135174
"Standard Order 384 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135175
"Standard Order 385 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135176
"Standard Order 386 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135177
"Standard Order 387 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135178
"Standard Order 388 - Pick up item 1 of 7 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -47.38366318)
writeFloat('[PlayerCoordinates]+84', -1264.429321)
writeFloat('[PlayerCoordinates]+88', 117.9734192)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135179
"Standard Order 388 - Pick up item 2, 3 of 7 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 212.8048248)
writeFloat('[PlayerCoordinates]+84', -1321.593384)
writeFloat('[PlayerCoordinates]+88', 111.9862213)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135180
"Standard Order 388 - Pick up item 4, 5, 6, 7 of 7 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 287.2895203)
writeFloat('[PlayerCoordinates]+84', -1231.669556)
writeFloat('[PlayerCoordinates]+88', 104.318367)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135181
"Standard Order 389 - Pick up 4 items in private locker of Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135182
"Standard Order 390 - Pick up item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',491.21932983398) -- X Coord
writeFloat('[PlayerCoordinates]+84',-601.34460449219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.21073913574) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135183
"Standard Order 390 - Pick up item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',487.66580200195) -- X Coord
writeFloat('[PlayerCoordinates]+84',-569.24041748047) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.71627807617) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135184
"Standard Order 390 - Pick up item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',550.62487792969) -- X Coord
writeFloat('[PlayerCoordinates]+84',-583.35632324219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',152.22630310059) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135185
"Teleport back to Vehicle (if one was used)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',465.45025634766) -- X Coord
writeFloat('[PlayerCoordinates]+84',-548.40533447266) -- Y Coord
writeFloat('[PlayerCoordinates]+88',159.51136779785) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135186
"Standard Order 391 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135187
"Standard Order 392 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135188
"Standard Order 628 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135189
"From First Prepper"
1
135190
"Teleport to: First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135191
"Standard Order 393 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135192
"Standard Order 394 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135193
"Standard Order 395 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135194
"Standard Order 396 - item 1/2"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -112.9052048)
writeFloat('[PlayerCoordinates]+84', 782.874939)
writeFloat('[PlayerCoordinates]+88', 736.6206665)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135195
"Standard Order 396 - item 2/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-111.63381958008) -- X Coord
writeFloat('[PlayerCoordinates]+84',815.31994628906) -- Y Coord
writeFloat('[PlayerCoordinates]+88',749.52471923828) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135196
"Standard Order 397 - Pick up item 1/5, 2/5 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 539.6925049)
writeFloat('[PlayerCoordinates]+84', 885.2458496)
writeFloat('[PlayerCoordinates]+88', 174.2861328)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135197
"Standard Order 397 - Pick up item 3/5, 4/5 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 676.0421753)
writeFloat('[PlayerCoordinates]+84', 721.0518188)
writeFloat('[PlayerCoordinates]+88', 164.790802)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135198
"Standard Order 397 - Pick up item 5/5 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1065.5354)
writeFloat('[PlayerCoordinates]+84', 921.6898804)
writeFloat('[PlayerCoordinates]+88', 160.447403)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135199
"Standard Order 398 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135200
"Standard Order 399 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135201
"Standard Order 400 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135202
"Standard Order 401 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135203
"Standard Order 402 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135204
"Standard Order 629 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135205
"From Collector"
1
135206
"Teleport to: Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135207
"Standard Order 403 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135208
"Standard Order 404 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135209
"Standard Order 405 - Pick up item 1 and 2 of 3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1450.897339)
writeFloat('[PlayerCoordinates]+84', 210.0477753)
writeFloat('[PlayerCoordinates]+88', 134.6021881)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135210
"Standard Order 405 - Pick up item 3 of 3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1416.170044)
writeFloat('[PlayerCoordinates]+84', 33.30061722)
writeFloat('[PlayerCoordinates]+88', 130.302597)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135211
"Standard Order 406 - Pick up 2 items in private locker of Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135212
"Standard Order 407 - Pick up item 1/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1331.0206298828) -- X Coord
writeFloat('[PlayerCoordinates]+84',1793.4057617188) -- Y Coord
writeFloat('[PlayerCoordinates]+88',199.20281982422) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135213
"Standard Order 407 - Pick up item 2/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1220.9906005859) -- X Coord
writeFloat('[PlayerCoordinates]+84',1755.6534423828) -- Y Coord
writeFloat('[PlayerCoordinates]+88',196.76161193848) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135214
"Standard Order 407 - Pick up item 3/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1203.73046875) -- X Coord
writeFloat('[PlayerCoordinates]+84',1722.3602294922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',192.4416809082) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135215
"Standard Order 407 - Pick up item 4/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1282.7908935547) -- X Coord
writeFloat('[PlayerCoordinates]+84',1760.9365234375) -- Y Coord
writeFloat('[PlayerCoordinates]+88',200.03823852539) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135216
"Standard Order 407 - Pick up item 5/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1232.9456787109) -- X Coord
writeFloat('[PlayerCoordinates]+84',1717.0611572266) -- Y Coord
writeFloat('[PlayerCoordinates]+88',198.32322692871) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135217
"Standard Order 407 - Pick up item 6/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1223.6373291016) -- X Coord
writeFloat('[PlayerCoordinates]+84',1689.0303955078) -- Y Coord
writeFloat('[PlayerCoordinates]+88',194.69314575195) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135218
"Standard Order 408 - Pick up 2 of 4 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1416.170044)
writeFloat('[PlayerCoordinates]+84', 33.30061722)
writeFloat('[PlayerCoordinates]+88', 130.302597)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135219
"Standard Order 408 - Pick up 2 of 4 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1322.740356)
writeFloat('[PlayerCoordinates]+84', -104.4131546)
writeFloat('[PlayerCoordinates]+88', 134.1850281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135220
"Standard Order 409 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135221
"Standard Order 410 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135222
"From Novelists's Son"
1
135223
"Teleport to: Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2441.5659179688)
writeFloat('[PlayerCoordinates]+84', 1291.0874023438)
writeFloat('[PlayerCoordinates]+88', 251.06520080566)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135224
"Standard Order 411 - Pick up item 1/3, 2/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1695.691895)
writeFloat('[PlayerCoordinates]+84', 1088.499268)
writeFloat('[PlayerCoordinates]+88', 220.418869)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135225
"Standard Order 411 - Pick up item 3/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1550.640991)
writeFloat('[PlayerCoordinates]+84', 1282.209595)
writeFloat('[PlayerCoordinates]+88', 241.9241943)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135226
"Standard Order 412 - Pick up item 1/3 & 2/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -758.4589233)
writeFloat('[PlayerCoordinates]+84', 1811.8302)
writeFloat('[PlayerCoordinates]+88', 224.3075867)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135227
"Standard Order 412 - Pick up item 3/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -852.6716919)
writeFloat('[PlayerCoordinates]+84', 1918.503418)
writeFloat('[PlayerCoordinates]+88', 224.05896)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135228
"Standard Order 413 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135229
"Standard Order 414 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135230
"Standard Order 415 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135231
"From Lake Knot City"
1
135232
"Teleport to: Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135233
"Standard Order 416, 417, 418 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135234
"Standard Order 419, 420, 421 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135235
"Standard Order 422, 423, 424 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135236
"Standard Order 425 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135237
"Standard Order 426 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135238
"Standard Order 427 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135239
"Standard Order 428 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135240
"Standard Order 429 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135241
"Standard Order 430 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135242
"Standard Order 431 - Pick up item 1/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2643.7341308594) -- X Coord
writeFloat('[PlayerCoordinates]+84',1650.79296875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',186.35159301758) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135243
"Standard Order 431 - Pick up item 2/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2645.2392578125) -- X Coord
writeFloat('[PlayerCoordinates]+84',1651.9138183594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',186.35159301758) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135244
"Standard Order 431 - Pick up item 3/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2629.369140625) -- X Coord
writeFloat('[PlayerCoordinates]+84',1673.3508300781) -- Y Coord
writeFloat('[PlayerCoordinates]+88',187.29302978516) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135245
"Standard Order 431 - Pick up item 4/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2608.0646972656) -- X Coord
writeFloat('[PlayerCoordinates]+84',1686.1666259766) -- Y Coord
writeFloat('[PlayerCoordinates]+88',186.35000610352) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135246
"Standard Order 431 - Pick up item 5/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2620.4162597656) -- X Coord
writeFloat('[PlayerCoordinates]+84',1672.0228271484) -- Y Coord
writeFloat('[PlayerCoordinates]+88',186.36024475098) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135247
"Standard Order 431 - Pick up item 6/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2619.669921875) -- X Coord
writeFloat('[PlayerCoordinates]+84',1673.0147705078) -- Y Coord
writeFloat('[PlayerCoordinates]+88',186.36024475098) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135248
"Standard Order 432 - Pick up item 1/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2636.3828125) -- X Coord
writeFloat('[PlayerCoordinates]+84',1711.1228027344) -- Y Coord
writeFloat('[PlayerCoordinates]+88',206.00738525391) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135249
"Standard Order 432 - Pick up item 2/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2621.7517089844) -- X Coord
writeFloat('[PlayerCoordinates]+84',1716.7515869141) -- Y Coord
writeFloat('[PlayerCoordinates]+88',206.35000610352) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135250
"Standard Order 432 - Pick up item 3/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2646.2548828125) -- X Coord
writeFloat('[PlayerCoordinates]+84',1739.2155761719) -- Y Coord
writeFloat('[PlayerCoordinates]+88',206.35987854004) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135251
"Standard Order 432 - Pick up item 4/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2644.0966796875) -- X Coord
writeFloat('[PlayerCoordinates]+84',1736.9255371094) -- Y Coord
writeFloat('[PlayerCoordinates]+88',206.35375976563) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135252
"Standard Order 432 - Pick up item 5/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2620.6096191406) -- X Coord
writeFloat('[PlayerCoordinates]+84',1717.2622070313) -- Y Coord
writeFloat('[PlayerCoordinates]+88',206.35472106934) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135253
"Standard Order 432 - Pick up item 6/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2620.6130371094) -- X Coord
writeFloat('[PlayerCoordinates]+84',1717.2227783203) -- Y Coord
writeFloat('[PlayerCoordinates]+88',206.35472106934) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135254
"Standard Order 432 - Pick up item 7/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2631.4592285156) -- X Coord
writeFloat('[PlayerCoordinates]+84',1705.5093994141) -- Y Coord
writeFloat('[PlayerCoordinates]+88',205.85018920898) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135255
"Standard Order 432 - Pick up item 8/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2647.2829589844) -- X Coord
writeFloat('[PlayerCoordinates]+84',1739.9847412109) -- Y Coord
writeFloat('[PlayerCoordinates]+88',206.35987854004) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135256
"Standard Order 432 - Pick up item 9/9"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2631.4206542969) -- X Coord
writeFloat('[PlayerCoordinates]+84',1705.4985351563) -- Y Coord
writeFloat('[PlayerCoordinates]+88',205.85018920898) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135257
"Standard Order 433 - Pick up 2 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2339.476074)
writeFloat('[PlayerCoordinates]+84', 1372.439453)
writeFloat('[PlayerCoordinates]+88', 182.6830597)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135258
"Standard Order 433 - Pick up 4 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2464.028809)
writeFloat('[PlayerCoordinates]+84', 1354.382446)
writeFloat('[PlayerCoordinates]+88', 186.3952332)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135259
"Standard Order 434, 435, 436 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135260
"Standard Order 437, 438, 439, 440 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135261
"Standard Order 441, 442 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135262
"Standard Order 443, 444 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135263
"Standard Order 630 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135264
"From Distribution Center South of Lake Knot City"
1
135265
"Teleport to: Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135266
"Standard Order 445, 446, 447 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2191.7585449219)
writeFloat('[PlayerCoordinates]+84', 1189.8968505859)
writeFloat('[PlayerCoordinates]+88', 178.52680969238)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135267
"Standard Order 448, 449 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135268
"Standard Order 450 - Pick up item 12.0kg/36.0kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',862.12353515625) -- X Coord
writeFloat('[PlayerCoordinates]+84',262.01596069336) -- Y Coord
writeFloat('[PlayerCoordinates]+88',153.19493103027) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135269
"Standard Order 450 - Pick up item 12.0kg/36.0kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',846.43505859375) -- X Coord
writeFloat('[PlayerCoordinates]+84',287.92260742188) -- Y Coord
writeFloat('[PlayerCoordinates]+88',153.13061523438) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135270
"Standard Order 450 - Pick up item 12.0kg/36.0kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',836.37646484375) -- X Coord
writeFloat('[PlayerCoordinates]+84',332.87594604492) -- Y Coord
writeFloat('[PlayerCoordinates]+88',153.86114501953) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135271
"Standard Order 450 - Teleport Back to Vehicle (if you used my vehicle location)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',871.43188476563) -- X Coord
writeFloat('[PlayerCoordinates]+84',257.96017456055) -- Y Coord
writeFloat('[PlayerCoordinates]+88',153.22640991211) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135272
"Standard Order 450 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1696.478515625)
writeFloat('[PlayerCoordinates]+84', 701.77563476563)
writeFloat('[PlayerCoordinates]+88', 245.24702453613)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135273
"Standard Order 451, 452, 453 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1226.0323486328)
writeFloat('[PlayerCoordinates]+84', 1317.2032470703)
writeFloat('[PlayerCoordinates]+88', 184.76554870605)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135274
"Standard Order 454 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135275
"Standard Order 455, 456, 457 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135276
"Standard Order 458 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135277
"Standard Order 459, 460, 461 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135278
"Standard Order 462 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135279
"Standard Order 463, 464 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135280
"Standard Order 465 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135281
"Standard Order 466 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135282
"Standard Order 467 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135283
"Standard Order 468, 469 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135284
"Standard Order 470 - Pick up 1 and 2 of 6 item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1322.740356)
writeFloat('[PlayerCoordinates]+84', -104.4131546)
writeFloat('[PlayerCoordinates]+88', 134.1850281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135285
"Standard Order 470 - Pick up 3 and 4 of 6 item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1416.170044)
writeFloat('[PlayerCoordinates]+84', 33.30061722)
writeFloat('[PlayerCoordinates]+88', 130.302597)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135286
"Standard Order 470 - Pick up 5 and 6 of 6 item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1450.897339)
writeFloat('[PlayerCoordinates]+84', 210.0477753)
writeFloat('[PlayerCoordinates]+88', 134.6021881)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135287
"Standard Order 470 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135288
"Standard Order 471 - Pick up item 1/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',703.19873046875) -- X Coord
writeFloat('[PlayerCoordinates]+84',187.30723571777) -- Y Coord
writeFloat('[PlayerCoordinates]+88',156.37690734863) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135289
"Standard Order 471 - Pick up item 2/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',763.42620849609) -- X Coord
writeFloat('[PlayerCoordinates]+84',210.00765991211) -- Y Coord
writeFloat('[PlayerCoordinates]+88',157.36068725586) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135290
"Standard Order 471 - Pick up item 3/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',758.22717285156) -- X Coord
writeFloat('[PlayerCoordinates]+84',205.92178344727) -- Y Coord
writeFloat('[PlayerCoordinates]+88',156.57052612305) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135291
"Standard Order 471 - Pick up item 4/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',700.22857666016) -- X Coord
writeFloat('[PlayerCoordinates]+84',145.33868408203) -- Y Coord
writeFloat('[PlayerCoordinates]+88',156.87934875488) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135292
"Standard Order 471 - Pick up item 5/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',699.17999267578) -- X Coord
writeFloat('[PlayerCoordinates]+84',192.0945892334) -- Y Coord
writeFloat('[PlayerCoordinates]+88',156.85620117188) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135293
"Standard Order 471 - Pick up item 6/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',663.24658203125) -- X Coord
writeFloat('[PlayerCoordinates]+84',206.90908813477) -- Y Coord
writeFloat('[PlayerCoordinates]+88',160.08493041992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135294
"Standard Order 471 - Pick up item 7/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',750.41253662109) -- X Coord
writeFloat('[PlayerCoordinates]+84',153.56562805176) -- Y Coord
writeFloat('[PlayerCoordinates]+88',157.40826416016) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135295
"Standard Order 471 - Pick up item 8/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',636.15747070313) -- X Coord
writeFloat('[PlayerCoordinates]+84',108.06601715088) -- Y Coord
writeFloat('[PlayerCoordinates]+88',160.63829040527) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135296
"Standard Order 471 - Pick up item 9/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',626.44677734375) -- X Coord
writeFloat('[PlayerCoordinates]+84',114.72227478027) -- Y Coord
writeFloat('[PlayerCoordinates]+88',165.02940368652) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135297
"Standard Order 471 - Pick up item 10/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',638.14392089844) -- X Coord
writeFloat('[PlayerCoordinates]+84',119.19952392578) -- Y Coord
writeFloat('[PlayerCoordinates]+88',161.19787597656) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135298
"Standard Order 472, 473 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135299
"Standard Order 474, 476 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135300
"Standard Order 475 - Pick up 4 of 12 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1065.5354)
writeFloat('[PlayerCoordinates]+84', 921.6898804)
writeFloat('[PlayerCoordinates]+88', 160.447403)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135301
"Standard Order 475 - Pick up 4 of 12 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 676.0421753)
writeFloat('[PlayerCoordinates]+84', 721.0518188)
writeFloat('[PlayerCoordinates]+88', 164.790802)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135302
"Standard Order 475 - Pick up 4 of 12 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 539.6925049)
writeFloat('[PlayerCoordinates]+84', 885.2458496)
writeFloat('[PlayerCoordinates]+88', 174.2861328)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135303
"Standard Order 475 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135304
"Standard Order 477 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135305
"Standard Order 478 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135306
"Standard Order 631 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135307
"Standard Order 632 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135308
"Standard Order 633 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135309
"From Weather Station"
1
135310
"Teleport to: Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135311
"Standard Order 479, 480 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135312
"Standard Order 481, 482 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135313
"Standard Order 483, 484 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135314
"Standard Order 485, 486 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135315
"Standard Order 487 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135316
"Standard Order 488 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135317
"Standard Order 489 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135318
"Standard Order 490 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135319
"Standard Order 491, 492, 493 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135320
"Standard Order 494 - Pick up item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',509.86560058594) -- X Coord
writeFloat('[PlayerCoordinates]+84',-445.77886962891) -- Y Coord
writeFloat('[PlayerCoordinates]+88',168.40008544922) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135321
"Standard Order 494 - Pick up item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',547.73132324219) -- X Coord
writeFloat('[PlayerCoordinates]+84',-371.74472045898) -- Y Coord
writeFloat('[PlayerCoordinates]+88',157.58891296387) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135322
"Standard Order 494 - Pick up item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',547.59631347656) -- X Coord
writeFloat('[PlayerCoordinates]+84',-447.39660644531) -- Y Coord
writeFloat('[PlayerCoordinates]+88',153.77732849121) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135323
"Standard Order 495, 496 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135324
"Standard Order 497, 498 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135325
"Standard Order 634 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135326
"Standard Order 635 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135327
"From South Knot City"
1
135328
"Teleport to: South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135329
"Standard Order 499 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135330
"Standard Order 500, 501 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.9134521484)
writeFloat('[PlayerCoordinates]+84', -275.56985473633)
writeFloat('[PlayerCoordinates]+88', 136.38018798828)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135331
"Standard Order 502, 503 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2152.3859863281)
writeFloat('[PlayerCoordinates]+84', -910.64288330078)
writeFloat('[PlayerCoordinates]+88', 156.43530273438)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135332
"Standard Order 504 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135333
"Standard Order 505 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135334
"Standard Order 506 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135335
"Standard Order 507 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135336
"Standard Order 508 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135337
"Standard Order 509, 510 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135338
"Standard Order 511 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135339
"Standard Order 512, 513 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135340
"Standard Order 514 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135341
"Standard Order 515 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135342
"From Mama's Lab"
1
135343
"Teleport to: Mama's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1022.6657714844)
writeFloat('[PlayerCoordinates]+84', -982.8818359375)
writeFloat('[PlayerCoordinates]+88', 163.03210449219)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135344
"Standard Order 516 - Pick up item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',468.17022705078) -- X Coord
writeFloat('[PlayerCoordinates]+84',-856.04345703125) -- Y Coord
writeFloat('[PlayerCoordinates]+88',101.35757446289) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135345
"Standard Order 516 - Pick up item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',464.43814086914) -- X Coord
writeFloat('[PlayerCoordinates]+84',-816.14617919922) -- Y Coord
writeFloat('[PlayerCoordinates]+88',100.6950378418) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135346
"Standard Order 516 - Pick up item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',600.62945556641) -- X Coord
writeFloat('[PlayerCoordinates]+84',-777.44671630859) -- Y Coord
writeFloat('[PlayerCoordinates]+88',83.410484313965) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135347
"Standard Order 516 - Pick up item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',517.16400146484) -- X Coord
writeFloat('[PlayerCoordinates]+84',-818.02856445313) -- Y Coord
writeFloat('[PlayerCoordinates]+88',84.021659851074) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135348
"Standard Order 516 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135349
"From Distribution Center North of Mountain Knot City"
1
135350
"Teleport to: Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135351
"Standard Order 517 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135352
"Standard Order 518, 519, 520 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135353
"Standard Order 521 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135354
"Standard Order 522, 523 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135355
"Standard Order 524, 525 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135356
"Standard Order 526 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135357
"Standard Order 527, 528 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135358
"Standard Order 529 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135359
"Standard Order 530 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135360
"Standard Order 531, 532, 533, 534, 535 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2441.5659179688)
writeFloat('[PlayerCoordinates]+84', 1291.0874023438)
writeFloat('[PlayerCoordinates]+88', 251.06520080566)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135361
"Standard Order 536 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135362
"Standard Order 537, 538 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1054.8397216797)
writeFloat('[PlayerCoordinates]+84', 413.9501953125)
writeFloat('[PlayerCoordinates]+88', 144.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135363
"Standard Order 539 - South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135364
"Standard Order 540 - Pick up 8 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -758.4589233)
writeFloat('[PlayerCoordinates]+84', 1811.8302)
writeFloat('[PlayerCoordinates]+88', 224.3075867)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135365
"Standard Order 541, 543 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135366
"Standard Order 542 - Pick up Item 1, 2, 3 out of 20 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1695.691895)
writeFloat('[PlayerCoordinates]+84', 1088.499268)
writeFloat('[PlayerCoordinates]+88', 220.418869)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135367
"Standard Order 542 - Pick up Item 4, 5, 6, 7, 8, 9, 10, 11 out of 20 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1550.640991)
writeFloat('[PlayerCoordinates]+84', 1282.209595)
writeFloat('[PlayerCoordinates]+88', 241.9241943)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135368
"Standard Order 542 - Pick up Item 12, 13, 14, 15, 16, 17, 18, 19, 20 out of 20 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2035.770142)
writeFloat('[PlayerCoordinates]+84', 1277.723877)
writeFloat('[PlayerCoordinates]+88', 223.827774)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135369
"Standard Order 542 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135370
"Standard Order 544, 545 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135371
"Standard Order 636 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135372
"From Mountain Knot City"
1
135373
"Teleport to: Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135374
"Standard Order 546, 547 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 184.68154907227)
writeFloat('[PlayerCoordinates]+84', 1642.2126464844)
writeFloat('[PlayerCoordinates]+88', 261.43435668945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135375
"Standard Order 548, 549 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135376
"Standard Order 550, 551 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -921.78460693359)
writeFloat('[PlayerCoordinates]+84', 1063.0844726563)
writeFloat('[PlayerCoordinates]+88', 599.85607910156)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135377
"Standard Order 552, 553 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2168.2016601563)
writeFloat('[PlayerCoordinates]+84', 603.51947021484)
writeFloat('[PlayerCoordinates]+88', 266.14349365234)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135378
"Standard Order 554, 555 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -319.4059753418)
writeFloat('[PlayerCoordinates]+84', 989.09338378906)
writeFloat('[PlayerCoordinates]+88', 737.16760253906)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135379
"Standard Order 556, 557, 558 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135380
"Standard Order 559, 560 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135381
"Standard Order 561 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135382
"Standard Order 562 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 92.446998596191)
writeFloat('[PlayerCoordinates]+84', -1618.1838378906)
writeFloat('[PlayerCoordinates]+88', 109.72776794434)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135383
"Standard Order 563, 564 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135384
"Standard Order 565, 566 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135385
"Standard Order 567, 568 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2001.1428222656)
writeFloat('[PlayerCoordinates]+84', -24.001985549927)
writeFloat('[PlayerCoordinates]+88', 153.35623168945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135386
"Standard Order 569, 570 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 719.26995849609)
writeFloat('[PlayerCoordinates]+84', -663.93426513672)
writeFloat('[PlayerCoordinates]+88', 101.74416351318)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135387
"Standard Order 571, 572 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135388
"Standard Order 573, 574 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1141.8942871094)
writeFloat('[PlayerCoordinates]+84', 29.015502929688)
writeFloat('[PlayerCoordinates]+88', 135.27490234375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135389
"Standard Order 575, 576 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2441.5659179688)
writeFloat('[PlayerCoordinates]+84', 1291.0874023438)
writeFloat('[PlayerCoordinates]+88', 251.06520080566)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135390
"Standard Order 577, 578 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2585.2846679688)
writeFloat('[PlayerCoordinates]+84', 2013.8199462891)
writeFloat('[PlayerCoordinates]+88', 209.47732543945)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135391
"Standard Order 579, 580 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 38.439750671387)
writeFloat('[PlayerCoordinates]+84', -74.023246765137)
writeFloat('[PlayerCoordinates]+88', 311.38076782227)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135392
"Standard Order 581 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1380.5748291016)
writeFloat('[PlayerCoordinates]+84', -1284.6726074219)
writeFloat('[PlayerCoordinates]+88', 139.29028320313)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135393
"Standard Order 582, 583 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1744.3016357422)
writeFloat('[PlayerCoordinates]+84', 2037.615234375)
writeFloat('[PlayerCoordinates]+88', 227.01776123047)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135394
"Standard Order 584, 585 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135395
"Standard Order 637 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135396
"From Heartman's Lab"
1
135397
"Teleport to: Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1214.4786376953)
writeFloat('[PlayerCoordinates]+84', -222.15846252441)
writeFloat('[PlayerCoordinates]+88', 532.83221435547)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135398
"Standard Order 586, 587 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -646.64099121094)
writeFloat('[PlayerCoordinates]+84', -144.66549682617)
writeFloat('[PlayerCoordinates]+88', 536.55578613281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135399
"Standard Order 588 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1427.6165771484)
writeFloat('[PlayerCoordinates]+84', 58.272735595703)
writeFloat('[PlayerCoordinates]+88', 360.59719848633)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135400
"Standard Order 589, 590 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -898.26202392578)
writeFloat('[PlayerCoordinates]+84', -789.72894287109)
writeFloat('[PlayerCoordinates]+88', 625.56060791016)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135401
"Standard Order 591, 592, 593 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1242.4761962891)
writeFloat('[PlayerCoordinates]+84', -1248.0733642578)
writeFloat('[PlayerCoordinates]+88', 412.21273803711)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135402
"Standard Order 594, 595 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1831.9169921875)
writeFloat('[PlayerCoordinates]+84', -705.4521484375)
writeFloat('[PlayerCoordinates]+88', 466.98864746094)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135403
"Standard Order 596, 597 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1100.3758544922)
writeFloat('[PlayerCoordinates]+84', 272.52059936523)
writeFloat('[PlayerCoordinates]+88', 353.3366394043)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135404
"Standard Order 598 - Pick up item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-952.75036621094) -- X Coord
writeFloat('[PlayerCoordinates]+84',-563.64349365234) -- Y Coord
writeFloat('[PlayerCoordinates]+88',646.71380615234) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135405
"Standard Order 598 - Pick up item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1015.104309082) -- X Coord
writeFloat('[PlayerCoordinates]+84',-588.52990722656) -- Y Coord
writeFloat('[PlayerCoordinates]+88',646.38073730469) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135406
"Standard Order 598 - Pick up item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-994.50756835938) -- X Coord
writeFloat('[PlayerCoordinates]+84',-616.8984375) -- Y Coord
writeFloat('[PlayerCoordinates]+88',675.55517578125) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135407
"Standard Order 598 - Pick up item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-966.36560058594) -- X Coord
writeFloat('[PlayerCoordinates]+84',-585.10198974609) -- Y Coord
writeFloat('[PlayerCoordinates]+88',655.16754150391) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135408
"Standard Order 598 - Teleport Back to Vehicle (if you used my vehicle location)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-990.73754882813) -- X Coord
writeFloat('[PlayerCoordinates]+84',-633.95098876953) -- Y Coord
writeFloat('[PlayerCoordinates]+88',687.26910400391) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135409
"Standard Order 599 - Pick up item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1149.2559814453) -- X Coord
writeFloat('[PlayerCoordinates]+84',-701.38165283203) -- Y Coord
writeFloat('[PlayerCoordinates]+88',634.49011230469) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135410
"Standard Order 599 - Pick up item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1087.2679443359) -- X Coord
writeFloat('[PlayerCoordinates]+84',-793.69873046875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',651.15222167969) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135411
"Standard Order 599 - Pick up item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1080.7044677734) -- X Coord
writeFloat('[PlayerCoordinates]+84',-799.2998046875) -- Y Coord
writeFloat('[PlayerCoordinates]+88',650.38024902344) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135412
"Standard Order 638 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -419.83605957031)
writeFloat('[PlayerCoordinates]+84', -1165.1920166016)
writeFloat('[PlayerCoordinates]+88', 250.94882202148)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135413
"Standard Order 639 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -220.34339904785)
writeFloat('[PlayerCoordinates]+84', 725.20837402344)
writeFloat('[PlayerCoordinates]+88', 788.54400634766)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135414
"Vehicle"
1
135415
"Eastern Region"
1
135416
"From Capital Knot City"
1
135417
"Teleport To: Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1443.4013671875) --X1
writeDouble('[VehicleCoordinates]+8F8', 1443.4013671875) --X2
writeDouble('[VehicleCoordinates]+D0', 692.111123512695) --Y1
writeDouble('[VehicleCoordinates]+900', 692.111123512695) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.306401471516) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.306401471516) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135418
"Standard Order 100, 101, 102 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135419
"Standard Order 105, 106 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1486.93542206135) --X1
writeDouble('[VehicleCoordinates]+8F8', -1486.93542206135) --X2
writeDouble('[VehicleCoordinates]+D0', 652.813289342022) --Y1
writeDouble('[VehicleCoordinates]+900', 652.813289342022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 204.475858193206) -- Z1
writeDouble('[VehicleCoordinates]+908', 204.475858193206) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135420
"Standard Order 107, 108 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135421
"Standard Order 109 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 92.6874055161516) --X1
writeDouble('[VehicleCoordinates]+8F8', 92.6874055161516) --X2
writeDouble('[VehicleCoordinates]+D0', 540.118915277497) --Y1
writeDouble('[VehicleCoordinates]+900', 540.118915277497) -- Y2
writeDouble('[VehicleCoordinates]+D8', 206.047497367006) -- Z1
writeDouble('[VehicleCoordinates]+908', 206.047497367006) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135422
"Standard Order 110, 111 - Deliver to Musician"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -981.190973857123) --X1
writeDouble('[VehicleCoordinates]+8F8', -981.190973857123) --X2
writeDouble('[VehicleCoordinates]+D0', -112.683721600795) --Y1
writeDouble('[VehicleCoordinates]+900', -112.683721600795) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.940941071383) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.940941071383) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135423
"From Waystation West of Capital Knot City"
1
135424
"Teleport to: Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135425
"Standard Order 112, 113 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1443.4013671875) --X1
writeDouble('[VehicleCoordinates]+8F8', 1443.4013671875) --X2
writeDouble('[VehicleCoordinates]+D0', 692.111123512695) --Y1
writeDouble('[VehicleCoordinates]+900', 692.111123512695) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.306401471516) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.306401471516) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135426
"Standard Order 114 - Pick Up 8 Items (East Side of River)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',532.21408843776) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',532.21408843776) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1304.7532501177) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1304.7532501177) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',134.30230713764) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',134.30230713764) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135427
"Standard Order 114 - (West Side of River)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',536.23840332031) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',536.23840332031) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1246.952020665) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1246.952020665) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',134.28976255667) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',134.28976255667) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135428
"Standard Order 114 - (Player Only) Teleport Back to Vehicle [East Side] (if you used my vehicle location)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',538.74273681641) -- X Coord
writeFloat('[PlayerCoordinates]+84',1297.1956787109) -- Y Coord
writeFloat('[PlayerCoordinates]+88',134.73930358887) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135429
"Notes: They are floating down the river"
1
135430
"Notes: Items Qty7 of 3.0kg, Qty1 of 68.0kg"
1
135431
"Standard Order 115, 116, 117, 118 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135432
"Standard Order 119, 120 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1486.93542206135) --X1
writeDouble('[VehicleCoordinates]+8F8', -1486.93542206135) --X2
writeDouble('[VehicleCoordinates]+D0', 652.813289342022) --Y1
writeDouble('[VehicleCoordinates]+900', 652.813289342022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 204.475858193206) -- Z1
writeDouble('[VehicleCoordinates]+908', 204.475858193206) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135433
"Standard Order 121 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135434
"Standard Order 122, 123, 124 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 92.6874055161516) --X1
writeDouble('[VehicleCoordinates]+8F8', 92.6874055161516) --X2
writeDouble('[VehicleCoordinates]+D0', 540.118915277497) --Y1
writeDouble('[VehicleCoordinates]+900', 540.118915277497) -- Y2
writeDouble('[VehicleCoordinates]+D8', 206.047497367006) -- Z1
writeDouble('[VehicleCoordinates]+908', 206.047497367006) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135435
"From Distribution Center West of Capital Knot City"
1
135436
"Teleport to: Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135437
"Standard Order 125, 126 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1443.4013671875) --X1
writeDouble('[VehicleCoordinates]+8F8', 1443.4013671875) --X2
writeDouble('[VehicleCoordinates]+D0', 692.111123512695) --Y1
writeDouble('[VehicleCoordinates]+900', 692.111123512695) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.306401471516) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.306401471516) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135438
"Standard Order 127 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135439
"Standard Order 128 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 353.032836914063) --X1
writeDouble('[VehicleCoordinates]+8F8', 353.032836914063) --X2
writeDouble('[VehicleCoordinates]+D0', 810.902099609375) --Y1
writeDouble('[VehicleCoordinates]+900', 810.902099609375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 162.930827675191) -- Z1
writeDouble('[VehicleCoordinates]+908', 162.930827675191) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135440
"Standard Order 128 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135441
"Standard Order 129 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -623.585700250143) --X1
writeDouble('[VehicleCoordinates]+8F8', -623.585700250143) --X2
writeDouble('[VehicleCoordinates]+D0', -109.13662082921) --Y1
writeDouble('[VehicleCoordinates]+900', -109.13662082921) -- Y2
writeDouble('[VehicleCoordinates]+D8', 222.927660603733) -- Z1
writeDouble('[VehicleCoordinates]+908', 222.927660603733) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135442
"Standard Order 130 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1486.93542206135) --X1
writeDouble('[VehicleCoordinates]+8F8', -1486.93542206135) --X2
writeDouble('[VehicleCoordinates]+D0', 652.813289342022) --Y1
writeDouble('[VehicleCoordinates]+900', 652.813289342022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 204.475858193206) -- Z1
writeDouble('[VehicleCoordinates]+908', 204.475858193206) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135443
"Standard Order 131 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135444
"Standard Order 132 - Deliver to Musician"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -981.190973857123) --X1
writeDouble('[VehicleCoordinates]+8F8', -981.190973857123) --X2
writeDouble('[VehicleCoordinates]+D0', -112.683721600795) --Y1
writeDouble('[VehicleCoordinates]+900', -112.683721600795) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.940941071383) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.940941071383) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135445
"From Wind Farm"
1
135446
"Teleport to: Wind Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1486.93542206135) --X1
writeDouble('[VehicleCoordinates]+8F8', -1486.93542206135) --X2
writeDouble('[VehicleCoordinates]+D0', 652.813289342022) --Y1
writeDouble('[VehicleCoordinates]+900', 652.813289342022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 204.475858193206) -- Z1
writeDouble('[VehicleCoordinates]+908', 204.475858193206) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135447
"Standard Order 133, 134, 135, 136, 137 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135448
"Standard Order 138, 139 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1443.4013671875) --X1
writeDouble('[VehicleCoordinates]+8F8', 1443.4013671875) --X2
writeDouble('[VehicleCoordinates]+D0', 692.111123512695) --Y1
writeDouble('[VehicleCoordinates]+900', 692.111123512695) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.306401471516) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.306401471516) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135449
"Standard Order 140, 141, 142 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135450
"Standard Order 143 - Item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1378.4102156853) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1378.4102156853) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',468.80740907897) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',468.80740907897) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',200.2093839658) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',200.2093839658) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135451
"Standard Order 143 - Item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1327.6213225094) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1327.6213225094) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',565.62432716825) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',565.62432716825) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',184.37596094245) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',184.37596094245) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135452
"Standard Order 143 - Item 3/3 (up the hill)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1375.4033008835) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1375.4033008835) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',613.39100092542) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',613.39100092542) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',201.18946009121) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',201.18946009121) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135453
"Standard Order 144 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 92.6874055161516) --X1
writeDouble('[VehicleCoordinates]+8F8', 92.6874055161516) --X2
writeDouble('[VehicleCoordinates]+D0', 540.118915277497) --Y1
writeDouble('[VehicleCoordinates]+900', 540.118915277497) -- Y2
writeDouble('[VehicleCoordinates]+D8', 206.047497367006) -- Z1
writeDouble('[VehicleCoordinates]+908', 206.047497367006) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135454
"Standard Order 600 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135455
"From Port Knot City"
1
135456
"Teleport to: Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135457
"Standard Order 145, 146 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1443.4013671875) --X1
writeDouble('[VehicleCoordinates]+8F8', 1443.4013671875) --X2
writeDouble('[VehicleCoordinates]+D0', 692.111123512695) --Y1
writeDouble('[VehicleCoordinates]+900', 692.111123512695) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.306401471516) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.306401471516) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135458
"Standard Order 147, 148 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135459
"Standard Order 149, 150 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135460
"Standard Order 151, 152 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1486.93542206135) --X1
writeDouble('[VehicleCoordinates]+8F8', -1486.93542206135) --X2
writeDouble('[VehicleCoordinates]+D0', 652.813289342022) --Y1
writeDouble('[VehicleCoordinates]+900', 652.813289342022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 204.475858193206) -- Z1
writeDouble('[VehicleCoordinates]+908', 204.475858193206) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135461
"Standard Order 153 - Pick up 3 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -623.585700250143) --X1
writeDouble('[VehicleCoordinates]+8F8', -623.585700250143) --X2
writeDouble('[VehicleCoordinates]+D0', -109.13662082921) --Y1
writeDouble('[VehicleCoordinates]+900', -109.13662082921) -- Y2
writeDouble('[VehicleCoordinates]+D8', 222.927660603733) -- Z1
writeDouble('[VehicleCoordinates]+908', 222.927660603733) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135462
"Standard Order 154, 155 - Deliver to Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 92.6874055161516) --X1
writeDouble('[VehicleCoordinates]+8F8', 92.6874055161516) --X2
writeDouble('[VehicleCoordinates]+D0', 540.118915277497) --Y1
writeDouble('[VehicleCoordinates]+900', 540.118915277497) -- Y2
writeDouble('[VehicleCoordinates]+D8', 206.047497367006) -- Z1
writeDouble('[VehicleCoordinates]+908', 206.047497367006) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135463
"From Luden's Fan"
1
135464
"Teleport to: Ludens Fan"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 92.6874055161516) --X1
writeDouble('[VehicleCoordinates]+8F8', 92.6874055161516) --X2
writeDouble('[VehicleCoordinates]+D0', 540.118915277497) --Y1
writeDouble('[VehicleCoordinates]+900', 540.118915277497) -- Y2
writeDouble('[VehicleCoordinates]+D8', 206.047497367006) -- Z1
writeDouble('[VehicleCoordinates]+908', 206.047497367006) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135465
"Standard Order 156 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1443.4013671875) --X1
writeDouble('[VehicleCoordinates]+8F8', 1443.4013671875) --X2
writeDouble('[VehicleCoordinates]+D0', 692.111123512695) --Y1
writeDouble('[VehicleCoordinates]+900', 692.111123512695) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.306401471516) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.306401471516) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135466
"Standard Order 157 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135467
"Standard Order 158 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135468
"Standard Order 159 - Deliver to Wind Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1486.93542206135) --X1
writeDouble('[VehicleCoordinates]+8F8', -1486.93542206135) --X2
writeDouble('[VehicleCoordinates]+D0', 652.813289342022) --Y1
writeDouble('[VehicleCoordinates]+900', 652.813289342022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 204.475858193206) -- Z1
writeDouble('[VehicleCoordinates]+908', 204.475858193206) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135469
"Standard Order 160 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135470
"Standard Order 161 - Pick up [2] items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 353.032836914063) --X1
writeDouble('[VehicleCoordinates]+8F8', 353.032836914063) --X2
writeDouble('[VehicleCoordinates]+D0', 810.902099609375) --Y1
writeDouble('[VehicleCoordinates]+900', 810.902099609375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 162.930827675191) -- Z1
writeDouble('[VehicleCoordinates]+908', 162.930827675191) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135471
"From Musician"
1
135472
"Teleport to: Musician"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -981.190973857123) --X1
writeDouble('[VehicleCoordinates]+8F8', -981.190973857123) --X2
writeDouble('[VehicleCoordinates]+D0', -112.683721600795) --Y1
writeDouble('[VehicleCoordinates]+900', -112.683721600795) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.940941071383) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.940941071383) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135473
"Standard Order 162, 163, 164, 165 - Deliver to Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1443.4013671875) --X1
writeDouble('[VehicleCoordinates]+8F8', 1443.4013671875) --X2
writeDouble('[VehicleCoordinates]+D0', 692.111123512695) --Y1
writeDouble('[VehicleCoordinates]+900', 692.111123512695) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.306401471516) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.306401471516) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135474
"Standard Order 166, 167 - Deliver to Waystation West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 318.790057202337) --X1
writeDouble('[VehicleCoordinates]+8F8', 318.790057202337) --X2
writeDouble('[VehicleCoordinates]+D0', 1162.37582811471) --Y1
writeDouble('[VehicleCoordinates]+900', 1162.37582811471) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.919248845007) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.919248845007) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135475
"Standard Order 168, 169, 170, 171 - Deliver to Distribution Center West of Capital Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -434.600480057907) --X1
writeDouble('[VehicleCoordinates]+8F8', -434.600480057907) --X2
writeDouble('[VehicleCoordinates]+D0', 265.06265072403) --Y1
writeDouble('[VehicleCoordinates]+900', 265.06265072403) -- Y2
writeDouble('[VehicleCoordinates]+D8', 136.354885042289) -- Z1
writeDouble('[VehicleCoordinates]+908', 136.354885042289) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135476
"Standard Order 172 - Item 1/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-782.28752085958) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-782.28752085958) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',5.2254852265058) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',5.2254852265058) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.49921917484) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.49921917484) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135477
"Standard Order 172 - Item 2/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-875.780507491395) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-875.780507491395) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',12.0616493516457) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',12.0616493516457) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',156.104103143793) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',156.104103143793) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135478
"Standard Order 601 - Deliver to Port Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1999.47536045469) --X1
writeDouble('[VehicleCoordinates]+8F8', -1999.47536045469) --X2
writeDouble('[VehicleCoordinates]+D0', -485.056854248047) --Y1
writeDouble('[VehicleCoordinates]+900', -485.056854248047) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.474717650577) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.474717650577) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135479
"Central Region"
1
135480
"From Engineer"
1
135481
"Teleport to: Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135482
"Standard Order 173 - Pick up 1/4 and 2/4 item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1617.93617112409) --X1
writeDouble('[VehicleCoordinates]+8F8', 1617.93617112409) --X2
writeDouble('[VehicleCoordinates]+D0', 1064.90197753906) --Y1
writeDouble('[VehicleCoordinates]+900', 1064.90197753906) -- Y2
writeDouble('[VehicleCoordinates]+D8', 175.162870201336) -- Z1
writeDouble('[VehicleCoordinates]+908', 175.162870201336) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135483
"Standard Order 173 - Pick up 3/4 and 4/4 item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1676.29306249085) --X1
writeDouble('[VehicleCoordinates]+8F8', 1676.29306249085) --X2
writeDouble('[VehicleCoordinates]+D0', 957.384109861756) --Y1
writeDouble('[VehicleCoordinates]+900', 957.384109861756) -- Y2
writeDouble('[VehicleCoordinates]+D8', 174.757174924946) -- Z1
writeDouble('[VehicleCoordinates]+908', 174.757174924946) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135484
"Standard Order 174 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135485
"Standard Order 175, 176 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135486
"Standard Order 177 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135487
"Standard Order 178 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135488
"Standard Order 179, 180 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135489
"Standard Order 181, 182 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135490
"Standard Order 183, 184 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135491
"Standard Order 185 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135492
"Standard Order 186, 187 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135493
"Standard Order 602 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135494
"From Elder"
1
135495
"Teleport to: Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135496
"Standard Order 188, 189 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135497
"Standard Order 190 - Pick up 1-3/8 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1520.09213235634) --X1
writeDouble('[VehicleCoordinates]+8F8', 1520.09213235634) --X2
writeDouble('[VehicleCoordinates]+D0', 994.568443457356) --Y1
writeDouble('[VehicleCoordinates]+900', 994.568443457356) -- Y2
writeDouble('[VehicleCoordinates]+D8', 172.358861432918) -- Z1
writeDouble('[VehicleCoordinates]+908', 172.358861432918) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135498
"Standard Order 190 - Pick up 4-5/8 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1676.29306249085) --X1
writeDouble('[VehicleCoordinates]+8F8', 1676.29306249085) --X2
writeDouble('[VehicleCoordinates]+D0', 957.384109861756) --Y1
writeDouble('[VehicleCoordinates]+900', 957.384109861756) -- Y2
writeDouble('[VehicleCoordinates]+D8', 174.757174924946) -- Z1
writeDouble('[VehicleCoordinates]+908', 174.757174924946) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135499
"Standard Order 190 - Pick up 6-8/8 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1617.93617112409) --X1
writeDouble('[VehicleCoordinates]+8F8', 1617.93617112409) --X2
writeDouble('[VehicleCoordinates]+D0', 1064.90197753906) --Y1
writeDouble('[VehicleCoordinates]+900', 1064.90197753906) -- Y2
writeDouble('[VehicleCoordinates]+D8', 175.162870201336) -- Z1
writeDouble('[VehicleCoordinates]+908', 175.162870201336) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135500
"Standard Order 191, 192 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135501
"Standard Order 193, 194 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135502
"Standard Order 195, 196 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135503
"Standard Order 197 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135504
"Standard Order 198 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135505
"Standard Order 603 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135506
"From Craftsman"
1
135507
"Teleport to: Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135508
"Standard Order 199, 200 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135509
"Standard Order 201 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135510
"Standard Order 202 - Pick up item at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 542.179931640625) --X1
writeDouble('[VehicleCoordinates]+8F8', 542.179931640625) --X2
writeDouble('[VehicleCoordinates]+D0', 883.924469714286) --Y1
writeDouble('[VehicleCoordinates]+900', 883.924469714286) -- Y2
writeDouble('[VehicleCoordinates]+D8', 173.255883735445) -- Z1
writeDouble('[VehicleCoordinates]+908', 173.255883735445) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135511
"Standard Order 202 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135512
"Standard Order 203 - Item 1/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1267.8548919228) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1267.8548919228) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1646.3246292339) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1646.3246292339) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',198.27245856991) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',198.27245856991) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135513
"Standard Order 203 - Item 2/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1257.75463867188) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1257.75463867188) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1666.81970214844) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1666.81970214844) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',195.882545684041) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',195.882545684041) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135514
"Standard Order 203 - Item 3/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1357.1895575324) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1357.1895575324) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1846.7839355469) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1846.7839355469) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',216.9525278956) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',216.9525278956) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135515
"Standard Order 203 - Item 4/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1319.7728271484) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1319.1868896484) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1642.3930664063) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1641.7930908203) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',234.86518859863) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',234.9733581543) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135516
"Standard Order 203 - Item 5/12 (Climb Up)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1345.455444) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1345.455444) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1666.74353) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1666.74353) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',202.34729) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',202.34729) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135517
"Standard Order 203 - Item 6/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1365.3018822422) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1365.3018822422) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1726.0574927578) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1726.0574927578) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',199.63899968271) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',199.63899968271) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135518
"Standard Order 203 - Item 7/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1210.1854578017) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1210.1854578017) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1695.7620058053) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1695.7620058053) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',193.52524614346) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',193.52524614346) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135519
"Standard Order 203 - Item 8/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1240.3508300781) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1240.3508300781) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1762.4304752998) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1762.4304752998) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',192.45311621568) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',192.45311621568) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135520
"Standard Order 203 - Item 9/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1279.0793660853) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1279.0793660853) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1814.3584493929) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1814.3584493929) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',195.39042671922) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',195.39042671922) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135521
"Standard Order 203 - Item 10/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1321.9486137072) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1321.9486137072) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1755.5569006608) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1755.5569006608) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',198.71090830573) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',198.71090830573) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135522
"Standard Order 203 - Item 11/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1306.7666247547) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1306.7666247547) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1754.9561118842) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1754.9561118842) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',197.82233535725) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',197.82233535725) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135523
"Standard Order 203 - Item 12/12"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1308.7158148351) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1308.7158148351) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1722.3410699305) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1722.3410699305) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',196.97431192659) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',196.97431192659) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135524
"Standard Order 204 - Pick up item"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1321.75479916266) --X1
writeDouble('[VehicleCoordinates]+8F8', 1321.75479916266) --X2
writeDouble('[VehicleCoordinates]+D0', 1781.333984375) --Y1
writeDouble('[VehicleCoordinates]+900', 1781.333984375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 199.04028204791) -- Z1
writeDouble('[VehicleCoordinates]+908', 199.04028204791) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135525
"Standard Order 205 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135526
"Standard Order 206 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135527
"Standard Order 207, 208 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135528
"Standard Order 209 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135529
"Standard Order 210, 211 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135530
"Standard Order 212 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135531
"Standard Order 213 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135532
"Standard Order 214, 215 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135533
"Standard Order 604 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135534
"From Timefall Farm"
1
135535
"Teleport to: Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135536
"Standard Order 216 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135537
"Standard Order 217, 218 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135538
"Standard Order 219 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135539
"Standard Order 220 - Pick up 2 of 5 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -45.4810066223145) --X1
writeDouble('[VehicleCoordinates]+8F8', -45.4810066223145) --X2
writeDouble('[VehicleCoordinates]+D0', -1266.28552246094) --Y1
writeDouble('[VehicleCoordinates]+900', -1266.28552246094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 116.924080021855) -- Z1
writeDouble('[VehicleCoordinates]+908', 116.924080021855) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135540
"Standard Order 220 - Pick up 3 of 5 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 286.290642498279) --X1
writeDouble('[VehicleCoordinates]+8F8', 286.290642498279) --X2
writeDouble('[VehicleCoordinates]+D0', -1225.44865830959) --Y1
writeDouble('[VehicleCoordinates]+900', -1225.44865830959) -- Y2
writeDouble('[VehicleCoordinates]+D8', 103.500809471737) -- Z1
writeDouble('[VehicleCoordinates]+908', 103.500809471737) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135541
"Standard Order 221 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135542
"Standard Order 222 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135543
"Standard Order 223 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135544
"Standard Order 224 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135545
"Standard Order 225 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135546
"Standard Order 226 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135547
"Standard Order 227, 228 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135548
"Standard Order 229 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135549
"Standard Order 230 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135550
"Standard Order 231 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135551
"Standard Order 605 - Pick up item 1/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',147.41123152994) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',147.41123152994) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1881.4320790162) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1881.4320790162) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',102.28429014757) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',102.28429014757) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135552
"Standard Order 605 - Pick up item 2/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',141.84106512118) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',141.84106512118) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1913.165530414) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1913.165530414) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',101.8128207686) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',101.8128207686) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135553
"Standard Order 605 - Pick up item 3/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',139.61857661471) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',139.61857661471) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1976.58422249) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1976.58422249) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',99.265052509785) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',99.265052509785) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135554
"Standard Order 605 - Pick up item 4/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',53.368358758482) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',53.368358758482) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-2019.4171142578) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-2019.4171142578) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',92.511147751415) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',92.511147751415) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135555
"Standard Order 605 - Pick up item 5/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',172.68481445313) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',172.68481445313) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-2087.3237304688) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-2087.3237304688) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',101.81091308594) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',101.81091308594) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135556
"Standard Order 605 - Pick up item 6/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',219.18691326596) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',219.18691326596) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1996.0391374235) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1996.0391374235) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',119.32598063679) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',119.32598063679) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135557
"Standard Order 605 - Deliver to Timefall Farm"
1
135558
"Standard Order 606 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135559
"Standard Order 607 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135560
"Standard Order 608 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135561
"From Junk Dealer"
1
135562
"Teleport to: Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135563
"Standard Order 232 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135564
"Standard Order 233, 234 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135565
"Standard Order 235 - Pick up 1/6 & 4/6 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1453.71704101563) --X1
writeDouble('[VehicleCoordinates]+8F8', 1453.71704101563) --X2
writeDouble('[VehicleCoordinates]+D0', 212.112176940245) --Y1
writeDouble('[VehicleCoordinates]+900', 212.112176940245) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.719818115234) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.719818115234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135566
"Standard Order 235 - Pick up 2/6 & 3/6 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1418.0397287627) --X1
writeDouble('[VehicleCoordinates]+8F8', 1418.0397287627) --X2
writeDouble('[VehicleCoordinates]+D0', 29.8784554046374) --Y1
writeDouble('[VehicleCoordinates]+900', 29.8784554046374) -- Y2
writeDouble('[VehicleCoordinates]+D8', 128.727154180244) -- Z1
writeDouble('[VehicleCoordinates]+908', 128.727154180244) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135567
"Standard Order 235 - Pick up 5/6 & 6/6 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1329.70216027083) --X1
writeDouble('[VehicleCoordinates]+8F8', 1329.70216027083) --X2
writeDouble('[VehicleCoordinates]+D0', -99.677134081765) --Y1
writeDouble('[VehicleCoordinates]+900', -99.677134081765) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.769827856341) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.769827856341) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135568
"Standard Order 236 - pick up 1/5, 3/5, 5/5 items in the hole"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',958.29585021564) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',958.29585021564) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-344.1984418655) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-344.1984418655) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',124.30037030346) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',124.30037030346) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135569
"Standard Order 236 - pick up 2/5 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1024.9230985239) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1024.9230985239) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-279.1773761947) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-279.1773761947) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',128.92820413863) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',128.92820413863) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135570
"Standard Order 236 - pick up 4/5 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',996.49557442751) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',996.49557442751) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-306.09789986696) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-306.09789986696) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',122.58292092403) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',122.58292092403) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135571
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1196.1630371895) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1196.1630371895) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-656.0759033604) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-656.0759033604) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',140.98315813245) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',140.98315813245) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135572
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1280.5443115234) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1280.5443115234) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-750.63696289063) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-750.63696289063) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',141.24099114128) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',141.24099114128) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135573
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1240.4854736328) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1240.4854736328) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-609.84149169922) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-609.84149169922) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',136.90911541924) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',136.90911541924) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135574
"Standard Order 237 - Pick up item - 10/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1205.4151138713) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1205.4151138713) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-625.61503749585) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-625.61503749585) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',139.63539247158) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',139.63539247158) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135575
"Standard Order 237 - Pick up item - 20/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1247.3529571525) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1247.3529571525) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-668.8130471562) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-668.8130471562) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',141.68599751819) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',141.68599751819) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135576
"Standard Order 237 - Pick up item - 20/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1221.5205154885) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1221.5205154885) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-667.15997436718) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-667.15997436718) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',145.02259149903) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',145.02259149903) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135577
"Standard Order 237 - Pick up item - 30/110kg"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1180.2353507674) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1180.2353507674) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-591.17808547624) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-591.17808547624) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',139.80634240771) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',139.80634240771) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135578
"Standard Order 238, 239, 240 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135579
"Standard Order 241 - Can't be done via vehicle"
1
135580
"Standard Order 242 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135581
"Standard Order 243 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135582
"Standard Order 244 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135583
"Standard Order 245 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135584
"Standard Order 246 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135585
"Standard Order 247 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135586
"Standard Order 248, 249, 250 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135587
"Standard Order 251, 252 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135588
"Standard Order 253, 254 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135589
"Standard Order 609 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135590
"From Chiral Artist's Studio"
1
135591
"Teleport to: Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135592
"Standard Order 255, 256, 257 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135593
"Standard Order 258 - item 1/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1437.9321402952) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1437.9321402952) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-849.57819742411) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-849.57819742411) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',126.99237641022) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',126.99237641022) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135594
"Standard Order 258 - item 4/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1453.1640257201) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1453.1640257201) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-861.52930775017) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-861.52930775017) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',127.77757157786) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',127.77757157786) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135595
"Standard Order 258 - item 2/6 & 5/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1478.8576395473) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1478.8576395473) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-910.5815253232) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-910.5815253232) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',128.14613801531) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',128.14613801531) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135596
"Standard Order 258 - item 3/6 & 6/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1490.5404031112) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1490.5404031112) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-958.72961966339) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-958.72961966339) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',127.23222074637) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',127.23222074637) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135597
"Standard Order 259 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135598
"Standard Order 260 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135599
"Standard Order 261 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135600
"Standard Order 262 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135601
"Standard Order 263, 264 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135602
"Standard Order 265 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135603
"Standard Order 266 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135604
"Standard Order 610 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135605
"Standard Order 611 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135606
"From Waystation North of Mountain Knot City"
1
135607
"Teleport to: Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135608
"Standard Order 267, 268 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135609
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-106.57125367397) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-106.57125367397) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1730.0203414074) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1730.0203414074) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',322.44619194296) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',322.44619194296) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135610
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-110.49656060829) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-110.49656060829) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1700.4948383556) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1700.4948383556) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',330.28547692626) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',330.28547692626) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135611
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-134.73580079686) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-134.73580079686) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1659.2966488947) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1659.2966488947) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',348.11319021941) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',348.11319021941) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135612
"Standard Order 269 - Pick up 1.2/4.8kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-174.32967754949) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-174.32967754949) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1706.1379804537) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1706.1379804537) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',349.85135555345) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',349.85135555345) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135613
"Standard Order 270, 271 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135614
"Standard Order 272, 273 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135615
"Standard Order 274, 275 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135616
"Standard Order 276, 277 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135617
"Standard Order 278 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135618
"Standard Order 279 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135619
"Standard Order 280, 281, 282 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135620
"Standard Order 283 - Pick up 1/4 & 2/4 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -762.880743824688) --X1
writeDouble('[VehicleCoordinates]+8F8', -762.880743824688) --X2
writeDouble('[VehicleCoordinates]+D0', 1811.14760256781) --Y1
writeDouble('[VehicleCoordinates]+900', 1811.14760256781) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.408607687459) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.408607687459) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135621
"Standard Order 283 - Pick up 3/4 & 4/4 items at MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -852.131401307823) --X1
writeDouble('[VehicleCoordinates]+8F8', -852.131401307823) --X2
writeDouble('[VehicleCoordinates]+D0', 1921.13070426408) --Y1
writeDouble('[VehicleCoordinates]+900', 1921.13070426408) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.012044045121) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.012044045121) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135622
"Standard Order 284 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135623
"Standard Order 612 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135624
"From Roboticist"
1
135625
"Teleport to: Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135626
"Standard Order 285, 286 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135627
"Standard Order 297 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2429.98510742188) --X1
writeDouble('[VehicleCoordinates]+8F8', -2429.98510742188) --X2
writeDouble('[VehicleCoordinates]+D0', 1292.8735588775) --Y1
writeDouble('[VehicleCoordinates]+900', 1292.8735588775) -- Y2
writeDouble('[VehicleCoordinates]+D8', 249.609417378204) -- Z1
writeDouble('[VehicleCoordinates]+908', 249.609417378204) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135628
"Standard Order 288, 289 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135629
"Standard Order 290 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135630
"Standard Order 291 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135631
"Standard Order 613 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135632
"Standard Order 614 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135633
"Standard Order 615 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135634
"Standard Order 616 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135635
"From Mountaineer"
1
135636
"Teleport to: Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135637
"Standard Order 292 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135638
"Standard Order 293 - item 1/4 (up the hill)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1020.9779745338) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1020.9779745338) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',801.54884572831) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',801.54884572831) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',452.56333922045) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',452.56333922045) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135639
"Standard Order 293 - item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1155.0991570321) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1155.0991570321) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',766.86851044722) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',766.86851044722) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',423.16703076116) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',423.16703076116) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135640
"Standard Order 293 - item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1078.751738712) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1078.751738712) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',714.22802705212) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',714.22802705212) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',420.56455322169) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',420.56455322169) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135641
"Standard Order 293 - item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1085.8330106226) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1085.8330106226) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',761.29662383418) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',761.29662383418) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',429.16905965509) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',429.16905965509) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135642
"Standard Order 294 - 2.5/50.5kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-847.37842134885) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-847.37842134885) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1379.042711089) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1379.042711089) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',513.79712083068) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',513.79712083068) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135643
"Standard Order 294 - 16.0/50.5kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-898.61132830308) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-898.61132830308) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1524.6029052734) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1524.6029052734) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',454.44966690505) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',454.44966690505) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135644
"Standard Order 294 - 32.0/50.5kg of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-874.58925656776) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-874.58925656776) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1467.8437384153) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1467.8437384153) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',472.547338556) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',472.547338556) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135645
"Standard Order 295 - Pick up 2 items from Doctor private locker"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135646
"Standard Order 296 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135647
"Standard Order 297 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135648
"Standard Order 298 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135649
"Standard Order 617 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135650
"Standard Order 618 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135651
"Standard Order 619 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135652
"From Photographer"
1
135653
"Teleport to: Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135654
"Standard Order 299 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135655
"Standard Order 300 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135656
"Standard Order 301 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135657
"Standard Order 302 - pick up item 1/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2363.0506020499) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2363.0506020499) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',942.06192211871) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',942.06192211871) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',213.18114305809) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',213.18114305809) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135658
"Standard Order 302 - pick up item 2/2 (floating down river)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2363.0506020499) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2363.0506020499) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',942.06192211871) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',942.06192211871) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',213.18114305809) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',213.18114305809) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135659
"Standard Order 303 - Pick up item 30.0/90.0 & 15.0/90.0 from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1549.63763756896) --X1
writeDouble('[VehicleCoordinates]+8F8', -1549.63763756896) --X2
writeDouble('[VehicleCoordinates]+D0', 1279.34696475638) --Y1
writeDouble('[VehicleCoordinates]+900', 1279.34696475638) -- Y2
writeDouble('[VehicleCoordinates]+D8', 240.661286312599) -- Z1
writeDouble('[VehicleCoordinates]+908', 240.661286312599) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135660
"Standard Order 303 - Pick up item 30.0/90.0 & 15.0/90.0 from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1698.36560058594) --X1
writeDouble('[VehicleCoordinates]+8F8', -1698.36560058594) --X2
writeDouble('[VehicleCoordinates]+D0', 1087.97488277915) --Y1
writeDouble('[VehicleCoordinates]+900', 1087.97488277915) -- Y2
writeDouble('[VehicleCoordinates]+D8', 219.390731680823) -- Z1
writeDouble('[VehicleCoordinates]+908', 219.390731680823) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135661
"Standard Order 304 - pick up item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1848.572265625) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1848.572265625) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',555.29579718184) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',555.29579718184) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',249.56055791295) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',249.56055791295) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135662
"Standard Order 304 - pick up item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1880.9894003657) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1880.9894003657) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',692.52956191218) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',692.52956191218) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',235.29332471947) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',235.29332471947) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135663
"Standard Order 304 - pick up item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1785.084732606) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1785.084732606) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',756.95251049835) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',756.95251049835) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',229.87956601978) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',229.87956601978) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135664
"Standard Order 305 - pick up item 1/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2554.8566894531) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2554.8566894531) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',701.13177075962) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',701.13177075962) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',214.09094807906) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',214.09094807906) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135665
"Standard Order 305 - pick up item 2/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2550.5119703665) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2550.5119703665) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',774.07172378449) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',774.07172378449) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',208.5499748704) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',208.5499748704) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135666
"Standard Order 305 - pick up item 3/5 (floating down river)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2452.7404280756) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2452.7404280756) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',729.03378846501) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',729.03378846501) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',218.50450595428) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',218.50450595428) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135667
"Standard Order 305 - pick up item 4/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2449.8762344045) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2449.8762344045) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',807.76465528819) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',807.76465528819) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',208.17579736513) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',208.17579736513) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135668
"Standard Order 305 - pick up item 5/5"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2583.8107988636) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2583.8107988636) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',775.45929936081) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',775.45929936081) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',208.82917981845) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',208.82917981845) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135669
"Standard Order 306 - Pick up item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1549.63763756896) --X1
writeDouble('[VehicleCoordinates]+8F8', -1549.63763756896) --X2
writeDouble('[VehicleCoordinates]+D0', 1279.34696475638) --Y1
writeDouble('[VehicleCoordinates]+900', 1279.34696475638) -- Y2
writeDouble('[VehicleCoordinates]+D8', 240.661286312599) -- Z1
writeDouble('[VehicleCoordinates]+908', 240.661286312599) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135670
"Standard Order 307 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135671
"Standard Order 308 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135672
"Standard Order 309 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135673
"Standard Order 310, 311 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135674
"From Spiritualist"
1
135675
"Teleport to: Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135676
"Standard Order 312 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135677
"Standard Order 313 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135678
"Standard Order 314 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135679
"Standard Order 315 - item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',363.29219637558) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',363.29219637558) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-557.45777600137) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-557.45777600137) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',182.6769389767) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',182.6769389767) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135680
"Standard Order 315 - item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',423.74906813702) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',423.74906813702) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-600.92645736403) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-600.92645736403) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.55702553523) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.55702553523) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135681
"Standard Order 315 - item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',348.55181884766) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',348.55181884766) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-596.10729980469) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-596.10729980469) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',174.07145690918) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',174.07145690918) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135682
"Standard Order 316 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135683
"Standard Order 317, 318 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135684
"Standard Order 319 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135685
"Standard Order 320 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135686
"Standard Order 321 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135687
"Standard Order 620 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135688
"From Doctor"
1
135689
"Teleport to: Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135690
"Standard Order 322 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135691
"Standard Order 323, 324 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135692
"Standard Order 325 - Grab 2 out of 3 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1549.63763756896) --X1
writeDouble('[VehicleCoordinates]+8F8', -1549.63763756896) --X2
writeDouble('[VehicleCoordinates]+D0', 1279.34696475638) --Y1
writeDouble('[VehicleCoordinates]+900', 1279.34696475638) -- Y2
writeDouble('[VehicleCoordinates]+D8', 240.661286312599) -- Z1
writeDouble('[VehicleCoordinates]+908', 240.661286312599) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135693
"Standard Order 325 - Grab 1 out of 3 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1698.36560058594) --X1
writeDouble('[VehicleCoordinates]+8F8', -1698.36560058594) --X2
writeDouble('[VehicleCoordinates]+D0', 1087.97488277915) --Y1
writeDouble('[VehicleCoordinates]+900', 1087.97488277915) -- Y2
writeDouble('[VehicleCoordinates]+D8', 219.390731680823) -- Z1
writeDouble('[VehicleCoordinates]+908', 219.390731680823) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135694
"Standard Order 326 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135695
"Standard Order 327 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2429.98510742188) --X1
writeDouble('[VehicleCoordinates]+8F8', -2429.98510742188) --X2
writeDouble('[VehicleCoordinates]+D0', 1292.8735588775) --Y1
writeDouble('[VehicleCoordinates]+900', 1292.8735588775) -- Y2
writeDouble('[VehicleCoordinates]+D8', 249.609417378204) -- Z1
writeDouble('[VehicleCoordinates]+908', 249.609417378204) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135696
"Standard Order 328 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135697
"Standard Order 329, 330 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135698
"Standard Order 331, 332 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135699
"Standard Order 333 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135700
"From Geologist"
1
135701
"Teleport to: Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135702
"Standard Order 334 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135703
"Standard Order 335, 336 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135704
"Standard Order 337 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135705
"Standard Order 338 - item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-703.69049658092) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-703.69049658092) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1152.8899694933) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1152.8899694933) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',391.2554409163) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',391.2554409163) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135706
"Standard Order 338 - item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-702.52904551612) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-702.52904551612) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1193.5121592797) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1193.5121592797) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',366.21221731609) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',366.21221731609) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135707
"Standard Order 338 - item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-684.22084039416) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-684.22084039416) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1122.7587121028) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1122.7587121028) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',409.28503397667) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',409.28503397667) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135708
"Standard Order 338 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135709
"Standard Order 339 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135710
"Standard Order 340, 341 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135711
"Standard Order 342 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135712
"Standard Order 343 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135713
"Standard Order 344 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135714
"Standard Order 621 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135715
"From Paleontologist"
1
135716
"Teleport to: Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135717
"Standard Order 345, 346 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135718
"Standard Order 347 - Pick up item 1/2 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1886.37829589844) --X1
writeDouble('[VehicleCoordinates]+8F8', -1886.37829589844) --X2
writeDouble('[VehicleCoordinates]+D0', -1422.99836564608) --Y1
writeDouble('[VehicleCoordinates]+900', -1422.99836564608) -- Y2
writeDouble('[VehicleCoordinates]+D8', 316.825536068178) -- Z1
writeDouble('[VehicleCoordinates]+908', 316.825536068178) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135719
"Standard Order 347 - Pick up item 2/2 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2031.86502385937) --X1
writeDouble('[VehicleCoordinates]+8F8', -2031.86502385937) --X2
writeDouble('[VehicleCoordinates]+D0', -1494.35781756771) --Y1
writeDouble('[VehicleCoordinates]+900', -1494.35781756771) -- Y2
writeDouble('[VehicleCoordinates]+D8', 285.722850381182) -- Z1
writeDouble('[VehicleCoordinates]+908', 285.722850381182) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135720
"Standard Order 348 - Pick up 5 items (need oxygen mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1367.2418212891) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1367.2418212891) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1339.6722412109) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1339.6722412109) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',338.92679330887) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',338.92679330887) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135721
"Standard Order 349 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135722
"Standard Order 350, 351 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135723
"Standard Order 352 - item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2013.1335006859) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2013.1335006859) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-986.71009980704) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-986.71009980704) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',314.51487843827) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',314.51487843827) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135724
"Standard Order 352 - item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2022.5320648579) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2022.5320648579) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1059.9523925781) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1059.9523925781) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',322.07672385274) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',322.07672385274) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135725
"Standard Order 352 - item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1934.5028009983) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1934.5028009983) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1014.3208618164) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1014.3208618164) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',324.29585873074) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',324.29585873074) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135726
"Standard Order 352 - item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1992.5492597812) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1992.5492597812) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1043.9993589354) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1043.9993589354) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',318.7481039047) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',318.7481039047) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135727
"Standard Order 352 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135728
"Standard Order 353 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135729
"Standard Order 354 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135730
"Standard Order 355 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135731
"Standard Order 356, 357 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135732
"From Veteran Porter"
1
135733
"Teleport to: Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135734
"Standard Order 358, 359 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135735
"Standard Order 360, 361 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135736
"Standard Order 362 - Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135737
"Standard Order 363 - Pick up item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',11.854673866904) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',11.854673866904) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-924.94092122136) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-924.94092122136) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',128.53994263086) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',128.53994263086) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135738
"Standard Order 363 - Pick up item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',37.278104784601) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',37.278104784601) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-972.22440127135) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-972.22440127135) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',126.6594808175) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',126.6594808175) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135739
"Standard Order 363 - Pick up item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',39.263241389672) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',39.263241389672) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1007.2879536069) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1007.2879536069) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',124.44816751317) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',124.44816751317) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135740
"Standard Order 363 - Pick up item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-39.205049653292) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-39.205049653292) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-883.49269767776) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-883.49269767776) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',139.55341548387) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',139.55341548387) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135741
"Standard Order 364 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135742
"Standard Order 365 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135743
"Standard Order 622 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135744
"Standard Order 623 - Pick up item 1/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 286.290642498279) --X1
writeDouble('[VehicleCoordinates]+8F8', 286.290642498279) --X2
writeDouble('[VehicleCoordinates]+D0', -1225.44865830959) --Y1
writeDouble('[VehicleCoordinates]+900', -1225.44865830959) -- Y2
writeDouble('[VehicleCoordinates]+D8', 103.500809471737) -- Z1
writeDouble('[VehicleCoordinates]+908', 103.500809471737) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135745
"Standard Order 623 - Pick up item 2/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 212.90758372087) --X1
writeDouble('[VehicleCoordinates]+8F8', 212.90758372087) --X2
writeDouble('[VehicleCoordinates]+D0', -1322.76818123451) --Y1
writeDouble('[VehicleCoordinates]+900', -1322.76818123451) -- Y2
writeDouble('[VehicleCoordinates]+D8', 110.773302238177) -- Z1
writeDouble('[VehicleCoordinates]+908', 110.773302238177) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135746
"Standard Order 623 - Pick up item 3/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -45.4810066223145) --X1
writeDouble('[VehicleCoordinates]+8F8', -45.4810066223145) --X2
writeDouble('[VehicleCoordinates]+D0', -1266.28552246094) --Y1
writeDouble('[VehicleCoordinates]+900', -1266.28552246094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 116.924080021855) -- Z1
writeDouble('[VehicleCoordinates]+908', 116.924080021855) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135747
"Standard Order 624 - Pick up 3 items from Geologist private locker"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135748
"Standard Order 625 - Pick up 3 items from Mountain Knot City private locker"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135749
"Standard Order 626 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135750
"From Evo-Devo Biologist"
1
135751
"Teleport to: Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135752
"Standard Order 366 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135753
"Standard Order 367 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135754
"Standard Order 368 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135755
"Standard Order 369, 370 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135756
"Standard Order 371 - Pick up 1 out of 2 items from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1970.29462433288) --X1
writeDouble('[VehicleCoordinates]+8F8', -1970.29462433288) --X2
writeDouble('[VehicleCoordinates]+D0', -1226.92988345318) --Y1
writeDouble('[VehicleCoordinates]+900', -1226.92988345318) -- Y2
writeDouble('[VehicleCoordinates]+D8', 317.755384444125) -- Z1
writeDouble('[VehicleCoordinates]+908', 317.755384444125) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135757
"Standard Order 371 - Pick up 1 out of 2 items from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1886.37829589844) --X1
writeDouble('[VehicleCoordinates]+8F8', -1886.37829589844) --X2
writeDouble('[VehicleCoordinates]+D0', -1422.99836564608) --Y1
writeDouble('[VehicleCoordinates]+900', -1422.99836564608) -- Y2
writeDouble('[VehicleCoordinates]+D8', 316.825536068178) -- Z1
writeDouble('[VehicleCoordinates]+908', 316.825536068178) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135758
"Standard Order 372 - Pick up 1/3 & 2/3 item (requires oxygen mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1367.9691180718) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1367.9691180718) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1339.9783935547) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1339.9783935547) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',338.89294526638) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',338.89294526638) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135759
"Standard Order 372 - Pick up 3/3 item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1398.1967773438) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1398.1967773438) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1367.8083534591) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1367.8083534591) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',359.53475855905) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',359.53475855905) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135760
"Standard Order 373 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135761
"Standard Order 374 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135762
"Standard Order 375 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135763
"Standard Order 376 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135764
"Standard Order 627 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135765
"From Film Director"
1
135766
"Teleport to: Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135767
"Standard Order 377 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135768
"Standard Order 378 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135769
"Standard Order 379 - Pick up 4 items in the river"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',622.46131481996) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',622.46131481996) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-596.44840383272) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-596.44840383272) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.83684553198) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.83684553198) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135770
"Standard Order 379 - (Player Only) Teleport Back to Vehicle"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',623.51251220703) -- X Coord
writeFloat('[PlayerCoordinates]+84',-601.41424560547) -- Y Coord
writeFloat('[PlayerCoordinates]+88',157.29495239258) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135771
"Standard Order 380 - Pick up 4 Items (Requires Oxygen Mask)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2194.0072407674) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2194.0072407674) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',303.16184733088) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',303.16184733088) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',173.26002681873) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',173.26002681873) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135772
"Standard Order 380 - (Player Only) Teleport Back to Vehicle"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',2197.001953125) -- X Coord
writeFloat('[PlayerCoordinates]+84',296.94464111328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',175.28324890137) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135773
"Standard Order 381 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135774
"Standard Order 382 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135775
"Standard Order 383 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135776
"From Cosplayer"
1
135777
"Teleport to: Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135778
"Standard Order 384 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135779
"Standard Order 385 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135780
"Standard Order 386 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135781
"Standard Order 387 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135782
"Standard Order 388 - Pick up item 1 of 7 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -45.4810066223145) --X1
writeDouble('[VehicleCoordinates]+8F8', -45.4810066223145) --X2
writeDouble('[VehicleCoordinates]+D0', -1266.28552246094) --Y1
writeDouble('[VehicleCoordinates]+900', -1266.28552246094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 116.924080021855) -- Z1
writeDouble('[VehicleCoordinates]+908', 116.924080021855) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135783
"Standard Order 388 - Pick up item 2, 3 of 7 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 212.90758372087) --X1
writeDouble('[VehicleCoordinates]+8F8', 212.90758372087) --X2
writeDouble('[VehicleCoordinates]+D0', -1322.76818123451) --Y1
writeDouble('[VehicleCoordinates]+900', -1322.76818123451) -- Y2
writeDouble('[VehicleCoordinates]+D8', 110.773302238177) -- Z1
writeDouble('[VehicleCoordinates]+908', 110.773302238177) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135784
"Standard Order 388 - Pick up item 4, 5, 6, 7 of 7 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 286.290642498279) --X1
writeDouble('[VehicleCoordinates]+8F8', 286.290642498279) --X2
writeDouble('[VehicleCoordinates]+D0', -1225.44865830959) --Y1
writeDouble('[VehicleCoordinates]+900', -1225.44865830959) -- Y2
writeDouble('[VehicleCoordinates]+D8', 103.500809471737) -- Z1
writeDouble('[VehicleCoordinates]+908', 103.500809471737) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135785
"Standard Order 389 - Pick up 4 items in private locker of Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135786
"Standard Order 390 - Pick up 3 items"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',468.97945988313) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',468.97945988313) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-553.7304683033) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-553.7304683033) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',158.61697264854) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',158.61697264854) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135787
"Standard Order 390 - (Player Only) Teleport back to Vehicle"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',465.45025634766) -- X Coord
writeFloat('[PlayerCoordinates]+84',-548.40533447266) -- Y Coord
writeFloat('[PlayerCoordinates]+88',159.51136779785) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135788
"Standard Order 391 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135789
"Standard Order 392 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135790
"Standard Order 628 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135791
"From First Prepper"
1
135792
"Teleport to: First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135793
"Standard Order 393 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135794
"Standard Order 394 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135795
"Standard Order 395 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135796
"Standard Order 396 - item 1/2"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-116.54009246826) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-116.54009246826) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',783.6116333) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',783.6116333) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',737.0638428) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',737.0638428) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135797
"Standard Order 396 - item 2/2 (West up the hill)"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-43.431091308594) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-43.431091308594) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',826.97729492188) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',826.97729492188) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',664.44244384766) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',664.44244384766) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135798
"Standard Order 397 - Pick up item 1/5, 2/5 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 542.179931640625) --X1
writeDouble('[VehicleCoordinates]+8F8', 542.179931640625) --X2
writeDouble('[VehicleCoordinates]+D0', 883.924469714286) --Y1
writeDouble('[VehicleCoordinates]+900', 883.924469714286) -- Y2
writeDouble('[VehicleCoordinates]+D8', 173.255883735445) -- Z1
writeDouble('[VehicleCoordinates]+908', 173.255883735445) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135799
"Standard Order 397 - Pick up item 3/5, 4/5 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 673.999725637608) --X1
writeDouble('[VehicleCoordinates]+8F8', 673.999725637608) --X2
writeDouble('[VehicleCoordinates]+D0', 722.279145174543) --Y1
writeDouble('[VehicleCoordinates]+900', 722.279145174543) -- Y2
writeDouble('[VehicleCoordinates]+D8', 163.758468332118) -- Z1
writeDouble('[VehicleCoordinates]+908', 163.758468332118) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135800
"Standard Order 397 - Pick up item 5/5 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1064.90069554793) --X1
writeDouble('[VehicleCoordinates]+8F8', 1064.90069554793) --X2
writeDouble('[VehicleCoordinates]+D0', 926.85973361315) --Y1
writeDouble('[VehicleCoordinates]+900', 926.85973361315) -- Y2
writeDouble('[VehicleCoordinates]+D8', 159.482284356258) -- Z1
writeDouble('[VehicleCoordinates]+908', 159.482284356258) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135801
"Standard Order 398 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135802
"Standard Order 399 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135803
"Standard Order 400 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135804
"Standard Order 401 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135805
"Standard Order 402 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135806
"Standard Order 629 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135807
"From Collector"
1
135808
"Teleport to: Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135809
"Standard Order 403 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135810
"Standard Order 404 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135811
"Standard Order 405 - Pick up item 1 and 2 of 3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1453.71704101563) --X1
writeDouble('[VehicleCoordinates]+8F8', 1453.71704101563) --X2
writeDouble('[VehicleCoordinates]+D0', 212.112176940245) --Y1
writeDouble('[VehicleCoordinates]+900', 212.112176940245) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.719818115234) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.719818115234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135812
"Standard Order 405 - Pick up item 3 of 3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1418.0397287627) --X1
writeDouble('[VehicleCoordinates]+8F8', 1418.0397287627) --X2
writeDouble('[VehicleCoordinates]+D0', 29.8784554046374) --Y1
writeDouble('[VehicleCoordinates]+900', 29.8784554046374) -- Y2
writeDouble('[VehicleCoordinates]+D8', 128.727154180244) -- Z1
writeDouble('[VehicleCoordinates]+908', 128.727154180244) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135813
"Standard Order 406 - Pick up 2 items in private locker of Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135814
"Standard Order 407 - Pick up item 1/6"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1321.75479916266) --X1
writeDouble('[VehicleCoordinates]+8F8', 1321.75479916266) --X2
writeDouble('[VehicleCoordinates]+D0', 1781.333984375) --Y1
writeDouble('[VehicleCoordinates]+900', 1781.333984375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 199.04028204791) -- Z1
writeDouble('[VehicleCoordinates]+908', 199.04028204791) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135815
"Standard Order 407 - Pick up item 2/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1236.1307947623) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1236.0378417969) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1771.5621218638) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1771.4079589844) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',197.44762137429) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',197.41754150391) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135816
"Standard Order 407 - Pick up item 3/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1208.7172244518) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1208.7172244518) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1700.1091915638) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1700.1091915638) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',193.42579634342) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',193.42579634342) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135817
"Standard Order 407 - Pick up item 4/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1273.5101212414) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1273.5101212414) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1777.1420602091) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1777.1420602091) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',194.56978920037) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',194.56978920037) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135818
"Standard Order 407 - Pick up item 5/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1214.4372575348) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1214.4372575348) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1714.5256832646) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1714.5256832646) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',192.51670899861) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',192.51670899861) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135819
"Standard Order 407 - Pick up item 6/6"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1208.7172244518) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1208.7172244518) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1700.1091915638) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1700.1091915638) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',193.42579634342) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',193.42579634342) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135820
"Standard Order 408 - Pick up 2 of 4 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1418.0397287627) --X1
writeDouble('[VehicleCoordinates]+8F8', 1418.0397287627) --X2
writeDouble('[VehicleCoordinates]+D0', 29.8784554046374) --Y1
writeDouble('[VehicleCoordinates]+900', 29.8784554046374) -- Y2
writeDouble('[VehicleCoordinates]+D8', 128.727154180244) -- Z1
writeDouble('[VehicleCoordinates]+908', 128.727154180244) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135821
"Standard Order 408 - Pick up 2 of 4 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1329.70216027083) --X1
writeDouble('[VehicleCoordinates]+8F8', 1329.70216027083) --X2
writeDouble('[VehicleCoordinates]+D0', -99.677134081765) --Y1
writeDouble('[VehicleCoordinates]+900', -99.677134081765) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.769827856341) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.769827856341) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135822
"Standard Order 409 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135823
"Standard Order 410 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135824
"From Novelists's Son"
1
135825
"Teleport to: Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2429.98510742188) --X1
writeDouble('[VehicleCoordinates]+8F8', -2429.98510742188) --X2
writeDouble('[VehicleCoordinates]+D0', 1292.8735588775) --Y1
writeDouble('[VehicleCoordinates]+900', 1292.8735588775) -- Y2
writeDouble('[VehicleCoordinates]+D8', 249.609417378204) -- Z1
writeDouble('[VehicleCoordinates]+908', 249.609417378204) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135826
"Standard Order 411 - Pick up item 1/3, 2/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1698.36560058594) --X1
writeDouble('[VehicleCoordinates]+8F8', -1698.36560058594) --X2
writeDouble('[VehicleCoordinates]+D0', 1087.97488277915) --Y1
writeDouble('[VehicleCoordinates]+900', 1087.97488277915) -- Y2
writeDouble('[VehicleCoordinates]+D8', 219.390731680823) -- Z1
writeDouble('[VehicleCoordinates]+908', 219.390731680823) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135827
"Standard Order 411 - Pick up item 3/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1549.63763756896) --X1
writeDouble('[VehicleCoordinates]+8F8', -1549.63763756896) --X2
writeDouble('[VehicleCoordinates]+D0', 1279.34696475638) --Y1
writeDouble('[VehicleCoordinates]+900', 1279.34696475638) -- Y2
writeDouble('[VehicleCoordinates]+D8', 240.661286312599) -- Z1
writeDouble('[VehicleCoordinates]+908', 240.661286312599) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135828
"Standard Order 412 - Pick up item 1/3 & 2/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -762.880743824688) --X1
writeDouble('[VehicleCoordinates]+8F8', -762.880743824688) --X2
writeDouble('[VehicleCoordinates]+D0', 1811.14760256781) --Y1
writeDouble('[VehicleCoordinates]+900', 1811.14760256781) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.408607687459) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.408607687459) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135829
"Standard Order 412 - Pick up item 3/3 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -852.131401307823) --X1
writeDouble('[VehicleCoordinates]+8F8', -852.131401307823) --X2
writeDouble('[VehicleCoordinates]+D0', 1921.13070426408) --Y1
writeDouble('[VehicleCoordinates]+900', 1921.13070426408) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.012044045121) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.012044045121) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135830
"Standard Order 413 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135831
"Standard Order 414 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135832
"Standard Order 415 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135833
"From Lake Knot City"
1
135834
"Teleport to: Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135835
"Standard Order 416, 417, 418 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135836
"Standard Order 419, 420, 421 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135837
"Standard Order 422, 423, 424 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135838
"Standard Order 425 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135839
"Standard Order 426 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135840
"Standard Order 427 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135841
"Standard Order 428 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135842
"Standard Order 429 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135843
"Standard Order 430 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135844
"Standard Order 431 - Pick up 6 items"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2635.0594470507) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2635.0594470507) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1661.0913097852) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1661.0913097852) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',185.3188211192) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',185.3188211192) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135845
"Standard Order 432 - Pick up 1, 2, 5, 6, 8, 9 of 9 of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2631.9213867188) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2631.9213867188) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1714.2733587196) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1714.2733587196) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',204.81868824387) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',204.81868824387) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135846
"Standard Order 432 - Pick up 3, 4, 9 of 9 of item"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',2654.6081542969) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',2654.6081542969) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1731.5268554688) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1731.5268554688) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',204.83534283414) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',204.83534283414) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135847
"Standard Order 433 - Pick up 2 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2339.37231445313) --X1
writeDouble('[VehicleCoordinates]+8F8', 2339.37231445313) --X2
writeDouble('[VehicleCoordinates]+D0', 1371.75949751723) --Y1
writeDouble('[VehicleCoordinates]+900', 1371.75949751723) -- Y2
writeDouble('[VehicleCoordinates]+D8', 181.743011474609) -- Z1
writeDouble('[VehicleCoordinates]+908', 181.743011474609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135848
"Standard Order 433 - Pick up 4 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2463.60405191884) --X1
writeDouble('[VehicleCoordinates]+8F8', 2463.60405191884) --X2
writeDouble('[VehicleCoordinates]+D0', 1354.73044474371) --Y1
writeDouble('[VehicleCoordinates]+900', 1354.73044474371) -- Y2
writeDouble('[VehicleCoordinates]+D8', 185.547360344177) -- Z1
writeDouble('[VehicleCoordinates]+908', 185.547360344177) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135849
"Standard Order 434, 435, 436 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135850
"Standard Order 437, 438, 439, 440 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135851
"Standard Order 441, 442 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135852
"Standard Order 443, 444 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135853
"Standard Order 630 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135854
"From Distribution Center South of Lake Knot City"
1
135855
"Teleport to: Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135856
"Standard Order 445, 446, 447 - Deliver to Engineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2184.02127121671) --X1
writeDouble('[VehicleCoordinates]+8F8', 2184.02127121671) --X2
writeDouble('[VehicleCoordinates]+D0', 1189.45777916304) --Y1
writeDouble('[VehicleCoordinates]+900', 1189.45777916304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 177.263346793139) -- Z1
writeDouble('[VehicleCoordinates]+908', 177.263346793139) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135857
"Standard Order 448, 449 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135858
"Standard Order 450 - Pick up 3 items"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',874.68406409558) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',874.68406409558) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',265.99862670898) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',265.99862670898) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',152.16543430012) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',152.16543430012) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135859
"Standard Order 450 - (Player Only) Teleport Back to Vehicle"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',871.43188476563) -- X Coord
writeFloat('[PlayerCoordinates]+84',257.96017456055) -- Y Coord
writeFloat('[PlayerCoordinates]+88',153.22640991211) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135860
"Standard Order 450 - Deliver to Elder"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1705.35144042969) --X1
writeDouble('[VehicleCoordinates]+8F8', 1705.35144042969) --X2
writeDouble('[VehicleCoordinates]+D0', 699.0947265625) --Y1
writeDouble('[VehicleCoordinates]+900', 699.0947265625) -- Y2
writeDouble('[VehicleCoordinates]+D8', 244.412511481352) -- Z1
writeDouble('[VehicleCoordinates]+908', 244.412511481352) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135861
"Standard Order 451, 452, 453 - Deliver to Craftsman"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1226.47027420112) --X1
writeDouble('[VehicleCoordinates]+8F8', 1226.47027420112) --X2
writeDouble('[VehicleCoordinates]+D0', 1307.98022460938) --Y1
writeDouble('[VehicleCoordinates]+900', 1307.98022460938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 183.580974329453) -- Z1
writeDouble('[VehicleCoordinates]+908', 183.580974329453) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135862
"Standard Order 454 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135863
"Standard Order 455, 456, 457 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135864
"Standard Order 458 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135865
"Standard Order 459, 460, 461 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135866
"Standard Order 462 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135867
"Standard Order 463, 464 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135868
"Standard Order 465 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135869
"Standard Order 466 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135870
"Standard Order 467 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135871
"Standard Order 468, 469 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135872
"Standard Order 470 - Pick up 1 and 2 of 6 item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1329.70216027083) --X1
writeDouble('[VehicleCoordinates]+8F8', 1329.70216027083) --X2
writeDouble('[VehicleCoordinates]+D0', -99.677134081765) --Y1
writeDouble('[VehicleCoordinates]+900', -99.677134081765) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.769827856341) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.769827856341) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135873
"Standard Order 470 - Pick up 3 and 4 of 6 item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1418.0397287627) --X1
writeDouble('[VehicleCoordinates]+8F8', 1418.0397287627) --X2
writeDouble('[VehicleCoordinates]+D0', 29.8784554046374) --Y1
writeDouble('[VehicleCoordinates]+900', 29.8784554046374) -- Y2
writeDouble('[VehicleCoordinates]+D8', 128.727154180244) -- Z1
writeDouble('[VehicleCoordinates]+908', 128.727154180244) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135874
"Standard Order 470 - Pick up 5 and 6 of 6 item from MULES Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1453.71704101563) --X1
writeDouble('[VehicleCoordinates]+8F8', 1453.71704101563) --X2
writeDouble('[VehicleCoordinates]+D0', 212.112176940245) --Y1
writeDouble('[VehicleCoordinates]+900', 212.112176940245) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.719818115234) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.719818115234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135875
"Standard Order 470 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135876
"Standard Order 471 - Pick up item 1/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',694.15516340401) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',694.15516340401) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',183.90393388603) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',183.90393388603) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.47574164098) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.47574164098) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135877
"Standard Order 471 - Pick up item 2/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',745.84764219745) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',745.84764219745) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',203.5121823865) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',203.5121823865) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.89416737236) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.89416737236) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135878
"Standard Order 471 - Pick up item 3/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',745.84764219745) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',745.84764219745) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',203.5121823865) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',203.5121823865) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.89416737236) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.89416737236) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135879
"Standard Order 471 - Pick up item 4/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',702.10377265527) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',702.10377265527) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',152.39650930103) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',152.39650930103) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.61605934589) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.61605934589) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135880
"Standard Order 471 - Pick up item 5/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',694.15516340401) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',694.15516340401) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',183.90393388603) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',183.90393388603) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.47574164098) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.47574164098) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135881
"Standard Order 471 - Pick up item 6/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',663.16403941518) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',651.63000488281) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',182.84749773848) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',216.02435302734) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',159.07428698113) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',161.08010864258) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135882
"Standard Order 471 - Pick up item 7/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',751.32877570901) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',751.32877570901) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',159.05488688036) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',159.05488688036) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.70265618439) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.70265618439) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135883
"Standard Order 471 - Pick up item 8/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',638.87801536752) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',638.87801536752) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',115.83717161227) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',115.83717161227) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',159.79027556732) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',159.79027556732) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135884
"Standard Order 471 - Pick up item 9/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',638.87801536752) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',638.87801536752) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',115.83717161227) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',115.83717161227) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',159.79027556732) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',159.79027556732) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135885
"Standard Order 471 - Pick up item 10/10"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',638.87801536752) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',638.87801536752) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',115.83717161227) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',115.83717161227) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',159.79027556732) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',159.79027556732) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135886
"Standard Order 472, 473 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135887
"Standard Order 474, 476 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135888
"Standard Order 475 - Pick up 4 of 12 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1064.90069554793) --X1
writeDouble('[VehicleCoordinates]+8F8', 1064.90069554793) --X2
writeDouble('[VehicleCoordinates]+D0', 926.85973361315) --Y1
writeDouble('[VehicleCoordinates]+900', 926.85973361315) -- Y2
writeDouble('[VehicleCoordinates]+D8', 159.482284356258) -- Z1
writeDouble('[VehicleCoordinates]+908', 159.482284356258) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135889
"Standard Order 475 - Pick up 4 of 12 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 673.999725637608) --X1
writeDouble('[VehicleCoordinates]+8F8', 673.999725637608) --X2
writeDouble('[VehicleCoordinates]+D0', 722.279145174543) --Y1
writeDouble('[VehicleCoordinates]+900', 722.279145174543) -- Y2
writeDouble('[VehicleCoordinates]+D8', 163.758468332118) -- Z1
writeDouble('[VehicleCoordinates]+908', 163.758468332118) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135890
"Standard Order 475 - Pick up 4 of 12 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 542.179931640625) --X1
writeDouble('[VehicleCoordinates]+8F8', 542.179931640625) --X2
writeDouble('[VehicleCoordinates]+D0', 883.924469714286) --Y1
writeDouble('[VehicleCoordinates]+900', 883.924469714286) -- Y2
writeDouble('[VehicleCoordinates]+D8', 173.255883735445) -- Z1
writeDouble('[VehicleCoordinates]+908', 173.255883735445) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135891
"Standard Order 475 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135892
"Standard Order 477 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135893
"Standard Order 478 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135894
"Standard Order 631 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135895
"Standard Order 632 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135896
"Standard Order 633 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135897
"From Weather Station"
1
135898
"Teleport to: Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135899
"Standard Order 479, 480 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135900
"Standard Order 481, 482 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135901
"Standard Order 483, 484 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135902
"Standard Order 485, 486 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135903
"Standard Order 487 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135904
"Standard Order 488 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135905
"Standard Order 489 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135906
"Standard Order 490 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135907
"Standard Order 491, 492, 493 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135908
"Standard Order 494 - Pick up item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',499.844119586) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',499.844119586) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-436.62975688497) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-436.62975688497) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',167.41021101718) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',167.41021101718) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135909
"Standard Order 494 - Pick up item 2/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',535.51287436488) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',535.51287436488) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-371.87997865718) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-371.87997865718) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',155.88347774737) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',155.88347774737) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135910
"Standard Order 494 - Pick up item 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',533.64145605157) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',533.64145605157) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-444.41544437845) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-444.41544437845) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',156.93405795194) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',156.93405795194) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135911
"Standard Order 495, 496 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135912
"Standard Order 497, 498 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135913
"Standard Order 634 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135914
"Standard Order 635 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135915
"From South Knot City"
1
135916
"Teleport to: South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135917
"Standard Order 499 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135918
"Standard Order 500, 501 - Deliver to Junk Dealer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1607.94860839844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1607.94860839844) --X2
writeDouble('[VehicleCoordinates]+D0', -274.140829576729) --Y1
writeDouble('[VehicleCoordinates]+900', -274.140829576729) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.984857813475) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.984857813475) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135919
"Standard Order 502, 503 - Deliver to Chiral Artist's Studio"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2140.7678905886) --X1
writeDouble('[VehicleCoordinates]+8F8', 2140.7678905886) --X2
writeDouble('[VehicleCoordinates]+D0', -891.205335171187) --Y1
writeDouble('[VehicleCoordinates]+900', -891.205335171187) -- Y2
writeDouble('[VehicleCoordinates]+D8', 149.236557576236) -- Z1
writeDouble('[VehicleCoordinates]+908', 149.236557576236) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135920
"Standard Order 504 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135921
"Standard Order 505 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135922
"Standard Order 506 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135923
"Standard Order 507 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135924
"Standard Order 508 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135925
"Standard Order 509, 510 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135926
"Standard Order 511 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135927
"Standard Order 512, 513 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135928
"Standard Order 514 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135929
"Standard Order 515 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135930
"From Mama's Lab"
1
135931
"Teleport to: Mama's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1013.66293989933) --X1
writeDouble('[VehicleCoordinates]+8F8', 1013.66293989933) --X2
writeDouble('[VehicleCoordinates]+D0', -973.060315833813) --Y1
writeDouble('[VehicleCoordinates]+900', -973.060315833813) -- Y2
writeDouble('[VehicleCoordinates]+D8', 161.76572519014) -- Z1
writeDouble('[VehicleCoordinates]+908', 161.76572519014) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135932
"Standard Order 516 - Pick up item 1/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',472.52000574194) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',472.52000574194) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-856.948457844) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-856.948457844) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',99.324810282258) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',99.324810282258) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135933
"Standard Order 516 - Pick up item 2/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',477.82701870966) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',477.82701870966) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-813.26383212041) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-813.26383212041) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',92.307882513056) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',92.307882513056) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135934
"Standard Order 516 - Pick up item 3/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',602.99721401595) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',602.99721401595) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-793.12836798771) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-793.12836798771) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',82.221621653415) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',82.221621653415) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135935
"Standard Order 516 - Pick up item 4/4"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',510.20526123047) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',510.20526123047) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-819.00867949137) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-819.00867949137) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',83.81810760498) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',83.81810760498) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135936
"Standard Order 516 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135937
"From Distribution Center North of Mountain Knot City"
1
135938
"Teleport to: Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135939
"Standard Order 517 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135940
"Standard Order 518, 519, 520 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135941
"Standard Order 521 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135942
"Standard Order 522, 523 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135943
"Standard Order 524, 525 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135944
"Standard Order 526 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135945
"Standard Order 527, 528 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135946
"Standard Order 529 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135947
"Standard Order 530 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135948
"Standard Order 531, 532, 533, 534, 535 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2429.98510742188) --X1
writeDouble('[VehicleCoordinates]+8F8', -2429.98510742188) --X2
writeDouble('[VehicleCoordinates]+D0', 1292.8735588775) --Y1
writeDouble('[VehicleCoordinates]+900', 1292.8735588775) -- Y2
writeDouble('[VehicleCoordinates]+D8', 249.609417378204) -- Z1
writeDouble('[VehicleCoordinates]+908', 249.609417378204) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135949
"Standard Order 536 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135950
"Standard Order 537, 538 - Deliver to Distribution Center South of Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1054.52221679688) --X1
writeDouble('[VehicleCoordinates]+8F8', 1054.52221679688) --X2
writeDouble('[VehicleCoordinates]+D0', 415.385344523893) --Y1
writeDouble('[VehicleCoordinates]+900', 415.385344523893) -- Y2
writeDouble('[VehicleCoordinates]+D8', 143.551446895804) -- Z1
writeDouble('[VehicleCoordinates]+908', 143.551446895804) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135951
"Standard Order 539 - South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135952
"Standard Order 540 - Pick up 8 items from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -762.880743824688) --X1
writeDouble('[VehicleCoordinates]+8F8', -762.880743824688) --X2
writeDouble('[VehicleCoordinates]+D0', 1811.14760256781) --Y1
writeDouble('[VehicleCoordinates]+900', 1811.14760256781) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.408607687459) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.408607687459) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135953
"Standard Order 541, 543 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135954
"Standard Order 542 - Pick up Item 1, 2, 3 out of 20 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1698.36560058594) --X1
writeDouble('[VehicleCoordinates]+8F8', -1698.36560058594) --X2
writeDouble('[VehicleCoordinates]+D0', 1087.97488277915) --Y1
writeDouble('[VehicleCoordinates]+900', 1087.97488277915) -- Y2
writeDouble('[VehicleCoordinates]+D8', 219.390731680823) -- Z1
writeDouble('[VehicleCoordinates]+908', 219.390731680823) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135955
"Standard Order 542 - Pick up Item 4, 5, 6, 7, 8, 9, 10, 11 out of 20 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1549.63763756896) --X1
writeDouble('[VehicleCoordinates]+8F8', -1549.63763756896) --X2
writeDouble('[VehicleCoordinates]+D0', 1279.34696475638) --Y1
writeDouble('[VehicleCoordinates]+900', 1279.34696475638) -- Y2
writeDouble('[VehicleCoordinates]+D8', 240.661286312599) -- Z1
writeDouble('[VehicleCoordinates]+908', 240.661286312599) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135956
"Standard Order 542 - Pick up Item 12, 13, 14, 15, 16, 17, 18, 19, 20 out of 20 from MULEs Postbox"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2031.99719238281) --X1
writeDouble('[VehicleCoordinates]+8F8', -2031.99719238281) --X2
writeDouble('[VehicleCoordinates]+D0', 1277.17714151068) --Y1
writeDouble('[VehicleCoordinates]+900', 1277.17714151068) -- Y2
writeDouble('[VehicleCoordinates]+D8', 222.56957095333) -- Z1
writeDouble('[VehicleCoordinates]+908', 222.56957095333) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135957
"Standard Order 542 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135958
"Standard Order 544, 545 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135959
"Standard Order 636 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135960
"From Mountain Knot City"
1
135961
"Teleport to: Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135962
"Standard Order 546, 547 - Deliver to Waystation North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 170.875869750977) --X1
writeDouble('[VehicleCoordinates]+8F8', 170.875869750977) --X2
writeDouble('[VehicleCoordinates]+D0', 1647.17614746094) --Y1
writeDouble('[VehicleCoordinates]+900', 1647.17614746094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 260.368743896484) -- Z1
writeDouble('[VehicleCoordinates]+908', 260.368743896484) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135963
"Standard Order 548, 549 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135964
"Standard Order 550, 551 - Deliver to Mountaineer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -939.111646158212) --X1
writeDouble('[VehicleCoordinates]+8F8', -939.111646158212) --X2
writeDouble('[VehicleCoordinates]+D0', 1058.93283134418) --Y1
writeDouble('[VehicleCoordinates]+900', 1058.93283134418) -- Y2
writeDouble('[VehicleCoordinates]+D8', 596.160614547307) -- Z1
writeDouble('[VehicleCoordinates]+908', 596.160614547307) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135965
"Standard Order 552, 553 - Deliver to Photographer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2159.29223628451) --X1
writeDouble('[VehicleCoordinates]+8F8', -2159.29223628451) --X2
writeDouble('[VehicleCoordinates]+D0', 606.801757861564) --Y1
writeDouble('[VehicleCoordinates]+900', 606.801757861564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 264.913360571171) -- Z1
writeDouble('[VehicleCoordinates]+908', 264.913360571171) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135966
"Standard Order 554, 555 - Deliver to Spiritualist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -325.113752107106) --X1
writeDouble('[VehicleCoordinates]+8F8', -325.113752107106) --X2
writeDouble('[VehicleCoordinates]+D0', 983.230529372708) --Y1
writeDouble('[VehicleCoordinates]+900', 983.230529372708) -- Y2
writeDouble('[VehicleCoordinates]+D8', 735.897462587294) -- Z1
writeDouble('[VehicleCoordinates]+908', 735.897462587294) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135967
"Standard Order 556, 557, 558 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135968
"Standard Order 559, 560 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135969
"Standard Order 561 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135970
"Standard Order 562 - Deliver to Timefall Farm"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 115.351102065019) --X1
writeDouble('[VehicleCoordinates]+8F8', 115.351102065019) --X2
writeDouble('[VehicleCoordinates]+D0', -1629.64987632092) --Y1
writeDouble('[VehicleCoordinates]+900', -1629.64987632092) -- Y2
writeDouble('[VehicleCoordinates]+D8', 108.919290458693) -- Z1
writeDouble('[VehicleCoordinates]+908', 108.919290458693) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135971
"Standard Order 563, 564 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135972
"Standard Order 565, 566 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135973
"Standard Order 567, 568 - Deliver to Film Director"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1997.68957519531) --X1
writeDouble('[VehicleCoordinates]+8F8', 1997.68957519531) --X2
writeDouble('[VehicleCoordinates]+D0', -15.4660186767578) --Y1
writeDouble('[VehicleCoordinates]+900', -15.4660186767578) -- Y2
writeDouble('[VehicleCoordinates]+D8', 151.910415649414) -- Z1
writeDouble('[VehicleCoordinates]+908', 151.910415649414) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135974
"Standard Order 569, 570 - Deliver to Cosplayer"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 738.7852565107) --X1
writeDouble('[VehicleCoordinates]+8F8', 738.7852565107) --X2
writeDouble('[VehicleCoordinates]+D0', -641.454963174569) --Y1
writeDouble('[VehicleCoordinates]+900', -641.454963174569) -- Y2
writeDouble('[VehicleCoordinates]+D8', 111.161303309287) -- Z1
writeDouble('[VehicleCoordinates]+908', 111.161303309287) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135975
"Standard Order 571, 572 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135976
"Standard Order 573, 574 - Deliver to Collector"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1151.38770162807) --X1
writeDouble('[VehicleCoordinates]+8F8', 1151.38770162807) --X2
writeDouble('[VehicleCoordinates]+D0', 29.2159338650015) --Y1
writeDouble('[VehicleCoordinates]+900', 29.2159338650015) -- Y2
writeDouble('[VehicleCoordinates]+D8', 134.269395761401) -- Z1
writeDouble('[VehicleCoordinates]+908', 134.269395761401) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135977
"Standard Order 575, 576 - Deliver to Novelists's Son"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2429.98510742188) --X1
writeDouble('[VehicleCoordinates]+8F8', -2429.98510742188) --X2
writeDouble('[VehicleCoordinates]+D0', 1292.8735588775) --Y1
writeDouble('[VehicleCoordinates]+900', 1292.8735588775) -- Y2
writeDouble('[VehicleCoordinates]+D8', 249.609417378204) -- Z1
writeDouble('[VehicleCoordinates]+908', 249.609417378204) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135978
"Standard Order 577, 578 - Deliver to Lake Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2578.24438476563) --X1
writeDouble('[VehicleCoordinates]+8F8', 2578.24438476563) --X2
writeDouble('[VehicleCoordinates]+D0', 2013.99584960938) --Y1
writeDouble('[VehicleCoordinates]+900', 2013.99584960938) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.465883132245) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.465883132245) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135979
"Standard Order 579, 580 - Deliver to Weather Station"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 51.3278233655956) --X1
writeDouble('[VehicleCoordinates]+8F8', 51.3278233655956) --X2
writeDouble('[VehicleCoordinates]+D0', -74.697151184082) --Y1
writeDouble('[VehicleCoordinates]+900', -74.697151184082) -- Y2
writeDouble('[VehicleCoordinates]+D8', 310.060264070773) -- Z1
writeDouble('[VehicleCoordinates]+908', 310.060264070773) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135980
"Standard Order 581 - Deliver to South Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1386.42834472656) --X1
writeDouble('[VehicleCoordinates]+8F8', 1386.42834472656) --X2
writeDouble('[VehicleCoordinates]+D0', -1286.35160940996) --Y1
writeDouble('[VehicleCoordinates]+900', -1286.35160940996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 138.261296221005) -- Z1
writeDouble('[VehicleCoordinates]+908', 138.261296221005) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135981
"Standard Order 582, 583 - Deliver to Distribution Center North of Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1746.50036621094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1746.50036621094) --X2
writeDouble('[VehicleCoordinates]+D0', 2039.28461942861) --Y1
writeDouble('[VehicleCoordinates]+900', 2039.28461942861) -- Y2
writeDouble('[VehicleCoordinates]+D8', 225.991669961092) -- Z1
writeDouble('[VehicleCoordinates]+908', 225.991669961092) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135982
"Standard Order 584, 585 - Deliver to Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135983
"Standard Order 637 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135984
"From Heartman's Lab"
1
135985
"Teleport to: Heartman's Lab"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1221.86779785156) --X1
writeDouble('[VehicleCoordinates]+8F8', -1221.86779785156) --X2
writeDouble('[VehicleCoordinates]+D0', -229.087647924799) --Y1
writeDouble('[VehicleCoordinates]+900', -229.087647924799) -- Y2
writeDouble('[VehicleCoordinates]+D8', 531.693955322326) -- Z1
writeDouble('[VehicleCoordinates]+908', 531.693955322326) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135986
"Standard Order 586, 587 - Deliver to Roboticist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -649.183700512192) --X1
writeDouble('[VehicleCoordinates]+8F8', -649.183700512192) --X2
writeDouble('[VehicleCoordinates]+D0', -136.553804305087) --Y1
writeDouble('[VehicleCoordinates]+900', -136.553804305087) -- Y2
writeDouble('[VehicleCoordinates]+D8', 535.161209155776) -- Z1
writeDouble('[VehicleCoordinates]+908', 535.161209155776) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135987
"Standard Order 588 - Deliver to Doctor"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1430.92370007196) --X1
writeDouble('[VehicleCoordinates]+8F8', -1430.92370007196) --X2
writeDouble('[VehicleCoordinates]+D0', 66.8332373271705) --Y1
writeDouble('[VehicleCoordinates]+900', 66.8332373271705) -- Y2
writeDouble('[VehicleCoordinates]+D8', 358.963532917869) -- Z1
writeDouble('[VehicleCoordinates]+908', 358.963532917869) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135988
"Standard Order 589, 590 - Deliver to Geologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -893.040383008573) --X1
writeDouble('[VehicleCoordinates]+8F8', -893.040383008573) --X2
writeDouble('[VehicleCoordinates]+D0', -783.167170839996) --Y1
writeDouble('[VehicleCoordinates]+900', -783.167170839996) -- Y2
writeDouble('[VehicleCoordinates]+D8', 624.149068809963) -- Z1
writeDouble('[VehicleCoordinates]+908', 624.149068809963) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135989
"Standard Order 591, 592, 593 - Deliver to Paleontologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1235.27709960938) --X1
writeDouble('[VehicleCoordinates]+8F8', -1235.27709960938) --X2
writeDouble('[VehicleCoordinates]+D0', -1252.37450712258) --Y1
writeDouble('[VehicleCoordinates]+900', -1252.37450712258) -- Y2
writeDouble('[VehicleCoordinates]+D8', 410.93840658829) -- Z1
writeDouble('[VehicleCoordinates]+908', 410.93840658829) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135990
"Standard Order 594, 595 - Deliver to Evo-devo Biologist"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1831.26241262823) --X1
writeDouble('[VehicleCoordinates]+8F8', -1831.26241262823) --X2
writeDouble('[VehicleCoordinates]+D0', -712.536589082141) --Y1
writeDouble('[VehicleCoordinates]+900', -712.536589082141) -- Y2
writeDouble('[VehicleCoordinates]+D8', 465.668199942371) -- Z1
writeDouble('[VehicleCoordinates]+908', 465.668199942371) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135991
"Standard Order 596, 597 - Deliver to Mountain Knot City"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1097.30987242924) --X1
writeDouble('[VehicleCoordinates]+8F8', -1097.30987242924) --X2
writeDouble('[VehicleCoordinates]+D0', 282.611919976647) --Y1
writeDouble('[VehicleCoordinates]+900', 282.611919976647) -- Y2
writeDouble('[VehicleCoordinates]+D8', 352.350160803609) -- Z1
writeDouble('[VehicleCoordinates]+908', 352.350160803609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135992
"Standard Order 598 - Pick up 4 items"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-991.72135703353) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-991.72135703353) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-629.81854770826) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-629.81854770826) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',682.24178317672) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',682.24178317672) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135993
"Standard Order 598 - (Player Only) Teleport Back to Vehicle"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-990.73754882813) -- X Coord
writeFloat('[PlayerCoordinates]+84',-633.95098876953) -- Y Coord
writeFloat('[PlayerCoordinates]+88',687.26910400391) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135994
"Standard Order 599 - Pick up item 1/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1156.4705406989) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1156.4705406989) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-712.16086824326) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-712.16086824326) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',629.47804777237) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',629.47804777237) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135995
"Standard Order 599 - Pick up item 2/3, 3/3"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1237.3637674405) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1237.3637674405) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-1258.2967487481) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-1258.2967487481) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',410.51202418713) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',410.51202418713) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
135996
"Standard Order 638 - Deliver to Veteran Porter"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -402.304512128479) --X1
writeDouble('[VehicleCoordinates]+8F8', -402.304512128479) --X2
writeDouble('[VehicleCoordinates]+D0', -1165.69761503304) --Y1
writeDouble('[VehicleCoordinates]+900', -1165.69761503304) -- Y2
writeDouble('[VehicleCoordinates]+D8', 247.350454353234) -- Z1
writeDouble('[VehicleCoordinates]+908', 247.350454353234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135997
"Standard Order 639 - Deliver to First Prepper"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -215.136096792216) --X1
writeDouble('[VehicleCoordinates]+8F8', -215.136096792216) --X2
writeDouble('[VehicleCoordinates]+D0', 718.149110347746) --Y1
writeDouble('[VehicleCoordinates]+900', 718.149110347746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 787.233213871004) -- Z1
writeDouble('[VehicleCoordinates]+908', 787.233213871004) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
135998
"Mule Postboxes [Dangerous]"
1
135999
"Eastern Region"
1
136000
"Player"
1
136001
"North Region"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 347.7147217)
writeFloat('[PlayerCoordinates]+84', 806.9052734)
writeFloat('[PlayerCoordinates]+88', 164.5243073)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136002
"South Region"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -622.9569702)
writeFloat('[PlayerCoordinates]+84', -107.1672058)
writeFloat('[PlayerCoordinates]+88', 223.7973175)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136003
"Ruined Factory - Outside"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',277.41485595703) -- X Coord
writeFloat('[PlayerCoordinates]+84',519.83526611328) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136004
"Ruined Factory - Inside"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',341.39114379883) -- X Coord
writeFloat('[PlayerCoordinates]+84',517.20544433594) -- Y Coord
writeFloat('[PlayerCoordinates]+88',298.10589599609) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136005
"Ruined Factory - Inside by Terminal"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',353.88189697266) -- X Coord
writeFloat('[PlayerCoordinates]+84',570.36444091797) -- Y Coord
writeFloat('[PlayerCoordinates]+88',291.35690307617) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136006
"Vehicle"
1
136007
"North Region"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 353.032836914063) --X1
writeDouble('[VehicleCoordinates]+8F8', 353.032836914063) --X2
writeDouble('[VehicleCoordinates]+D0', 810.902099609375) --Y1
writeDouble('[VehicleCoordinates]+900', 810.902099609375) -- Y2
writeDouble('[VehicleCoordinates]+D8', 162.930827675191) -- Z1
writeDouble('[VehicleCoordinates]+908', 162.930827675191) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136008
"South Region"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -623.585700250143) --X1
writeDouble('[VehicleCoordinates]+8F8', -623.585700250143) --X2
writeDouble('[VehicleCoordinates]+D0', -109.13662082921) --Y1
writeDouble('[VehicleCoordinates]+900', -109.13662082921) -- Y2
writeDouble('[VehicleCoordinates]+D8', 222.927660603733) -- Z1
writeDouble('[VehicleCoordinates]+908', 222.927660603733) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136009
"Central Region"
1
136010
"Player"
1
136011
"South of Lake Knot City #1 (West Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2339.476074)
writeFloat('[PlayerCoordinates]+84', 1372.439453)
writeFloat('[PlayerCoordinates]+88', 182.6830597)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136012
"South of Lake Knot City #2 (East Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2464.028809)
writeFloat('[PlayerCoordinates]+84', 1354.382446)
writeFloat('[PlayerCoordinates]+88', 186.3952332)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136013
"West of Engineer #1 (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1674.913452)
writeFloat('[PlayerCoordinates]+84', 960.6556396)
writeFloat('[PlayerCoordinates]+88', 175.3177338)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136014
"West of Engineer #2 (North Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.813354)
writeFloat('[PlayerCoordinates]+84', 1064.050903)
writeFloat('[PlayerCoordinates]+88', 176.1360779)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136015
"West of Engineer #3 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1519.881714)
writeFloat('[PlayerCoordinates]+84', 992.4251099)
writeFloat('[PlayerCoordinates]+88', 173.4361572)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136016
"South West of Craftsman #1 (Northeast Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1065.5354)
writeFloat('[PlayerCoordinates]+84', 921.6898804)
writeFloat('[PlayerCoordinates]+88', 160.447403)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136017
"South West of Craftsman #2 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 676.0421753)
writeFloat('[PlayerCoordinates]+84', 721.0518188)
writeFloat('[PlayerCoordinates]+88', 164.790802)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136018
"South West of Craftsman #3 (NorthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 539.6925049)
writeFloat('[PlayerCoordinates]+84', 885.2458496)
writeFloat('[PlayerCoordinates]+88', 174.2861328)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136019
"Area Surrounding Collector #1 (North Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1450.897339)
writeFloat('[PlayerCoordinates]+84', 210.0477753)
writeFloat('[PlayerCoordinates]+88', 134.6021881)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136020
"Area Surrounding Collector #2 (Center Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1416.170044)
writeFloat('[PlayerCoordinates]+84', 33.30061722)
writeFloat('[PlayerCoordinates]+88', 130.302597)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136021
"Area Surrounding Collector #3 (South Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1322.740356)
writeFloat('[PlayerCoordinates]+84', -104.4131546)
writeFloat('[PlayerCoordinates]+88', 134.1850281)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136022
"North of Timefall Farm #1 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -47.38366318)
writeFloat('[PlayerCoordinates]+84', -1264.429321)
writeFloat('[PlayerCoordinates]+88', 117.9734192)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136023
"North of Timefall Farm #2 (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 212.8048248)
writeFloat('[PlayerCoordinates]+84', -1321.593384)
writeFloat('[PlayerCoordinates]+88', 111.9862213)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136024
"North of Timefall Farm #3 (East Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 287.2895203)
writeFloat('[PlayerCoordinates]+84', -1231.669556)
writeFloat('[PlayerCoordinates]+88', 104.318367)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136025
"East of Distribution Center North of Mountain Knot City (NorthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -852.6716919)
writeFloat('[PlayerCoordinates]+84', 1918.503418)
writeFloat('[PlayerCoordinates]+88', 224.05896)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136026
"East of Distribution Center North of Mountain Knot City (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -758.4589233)
writeFloat('[PlayerCoordinates]+84', 1811.8302)
writeFloat('[PlayerCoordinates]+88', 224.3075867)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136027
"West of Mountaineer #1 (NorthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1550.640991)
writeFloat('[PlayerCoordinates]+84', 1282.209595)
writeFloat('[PlayerCoordinates]+88', 241.9241943)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136028
"West of Mountaineer #2 (South/Center Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1695.691895)
writeFloat('[PlayerCoordinates]+84', 1088.499268)
writeFloat('[PlayerCoordinates]+88', 220.418869)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136029
"West of Mountaineer #3 (NorthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2035.770142)
writeFloat('[PlayerCoordinates]+84', 1277.723877)
writeFloat('[PlayerCoordinates]+88', 223.827774)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136030
"West of Paleontologist #1 (North Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1973.025146)
writeFloat('[PlayerCoordinates]+84', -1232.20105)
writeFloat('[PlayerCoordinates]+88', 319.3590088)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136031
"West of Paleontologist #2 (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1888.633545)
writeFloat('[PlayerCoordinates]+84', -1423.368896)
writeFloat('[PlayerCoordinates]+88', 317.8652344)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136032
"West of Paleontologist #3 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2034.582642)
writeFloat('[PlayerCoordinates]+84', -1499.935303)
writeFloat('[PlayerCoordinates]+88', 287.5764771)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136033
"Vehicle"
1
136034
"South of Lake Knot City #1 (West Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2339.37231445313) --X1
writeDouble('[VehicleCoordinates]+8F8', 2339.37231445313) --X2
writeDouble('[VehicleCoordinates]+D0', 1371.75949751723) --Y1
writeDouble('[VehicleCoordinates]+900', 1371.75949751723) -- Y2
writeDouble('[VehicleCoordinates]+D8', 181.743011474609) -- Z1
writeDouble('[VehicleCoordinates]+908', 181.743011474609) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136035
"South of Lake Knot City #2 (East Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2463.60405191884) --X1
writeDouble('[VehicleCoordinates]+8F8', 2463.60405191884) --X2
writeDouble('[VehicleCoordinates]+D0', 1354.73044474371) --Y1
writeDouble('[VehicleCoordinates]+900', 1354.73044474371) -- Y2
writeDouble('[VehicleCoordinates]+D8', 185.547360344177) -- Z1
writeDouble('[VehicleCoordinates]+908', 185.547360344177) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136036
"West of Engineer #1 (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1676.29306249085) --X1
writeDouble('[VehicleCoordinates]+8F8', 1676.29306249085) --X2
writeDouble('[VehicleCoordinates]+D0', 957.384109861756) --Y1
writeDouble('[VehicleCoordinates]+900', 957.384109861756) -- Y2
writeDouble('[VehicleCoordinates]+D8', 174.757174924946) -- Z1
writeDouble('[VehicleCoordinates]+908', 174.757174924946) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136037
"West of Engineer #2 (North Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1617.93617112409) --X1
writeDouble('[VehicleCoordinates]+8F8', 1617.93617112409) --X2
writeDouble('[VehicleCoordinates]+D0', 1064.90197753906) --Y1
writeDouble('[VehicleCoordinates]+900', 1064.90197753906) -- Y2
writeDouble('[VehicleCoordinates]+D8', 175.162870201336) -- Z1
writeDouble('[VehicleCoordinates]+908', 175.162870201336) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136038
"West of Engineer #3 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1520.09213235634) --X1
writeDouble('[VehicleCoordinates]+8F8', 1520.09213235634) --X2
writeDouble('[VehicleCoordinates]+D0', 994.568443457356) --Y1
writeDouble('[VehicleCoordinates]+900', 994.568443457356) -- Y2
writeDouble('[VehicleCoordinates]+D8', 172.358861432918) -- Z1
writeDouble('[VehicleCoordinates]+908', 172.358861432918) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136039
"South West of Craftsman #1 (Northeast Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1064.90069554793) --X1
writeDouble('[VehicleCoordinates]+8F8', 1064.90069554793) --X2
writeDouble('[VehicleCoordinates]+D0', 926.85973361315) --Y1
writeDouble('[VehicleCoordinates]+900', 926.85973361315) -- Y2
writeDouble('[VehicleCoordinates]+D8', 159.482284356258) -- Z1
writeDouble('[VehicleCoordinates]+908', 159.482284356258) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136040
"South West of Craftsman #2 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 673.999725637608) --X1
writeDouble('[VehicleCoordinates]+8F8', 673.999725637608) --X2
writeDouble('[VehicleCoordinates]+D0', 722.279145174543) --Y1
writeDouble('[VehicleCoordinates]+900', 722.279145174543) -- Y2
writeDouble('[VehicleCoordinates]+D8', 163.758468332118) -- Z1
writeDouble('[VehicleCoordinates]+908', 163.758468332118) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136041
"South West of Craftsman #3 (NorthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 542.179931640625) --X1
writeDouble('[VehicleCoordinates]+8F8', 542.179931640625) --X2
writeDouble('[VehicleCoordinates]+D0', 883.924469714286) --Y1
writeDouble('[VehicleCoordinates]+900', 883.924469714286) -- Y2
writeDouble('[VehicleCoordinates]+D8', 173.255883735445) -- Z1
writeDouble('[VehicleCoordinates]+908', 173.255883735445) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136042
"Area Surrounding Collector #1 (North Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1453.71704101563) --X1
writeDouble('[VehicleCoordinates]+8F8', 1453.71704101563) --X2
writeDouble('[VehicleCoordinates]+D0', 212.112176940245) --Y1
writeDouble('[VehicleCoordinates]+900', 212.112176940245) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.719818115234) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.719818115234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136043
"Area Surrounding Collector #2 (Center Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1418.0397287627) --X1
writeDouble('[VehicleCoordinates]+8F8', 1418.0397287627) --X2
writeDouble('[VehicleCoordinates]+D0', 29.8784554046374) --Y1
writeDouble('[VehicleCoordinates]+900', 29.8784554046374) -- Y2
writeDouble('[VehicleCoordinates]+D8', 128.727154180244) -- Z1
writeDouble('[VehicleCoordinates]+908', 128.727154180244) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136044
"Area Surrounding Collector #3 (South Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1329.70216027083) --X1
writeDouble('[VehicleCoordinates]+8F8', 1329.70216027083) --X2
writeDouble('[VehicleCoordinates]+D0', -99.677134081765) --Y1
writeDouble('[VehicleCoordinates]+900', -99.677134081765) -- Y2
writeDouble('[VehicleCoordinates]+D8', 133.769827856341) -- Z1
writeDouble('[VehicleCoordinates]+908', 133.769827856341) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136045
"North of Timefall Farm #1 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -45.4810066223145) --X1
writeDouble('[VehicleCoordinates]+8F8', -45.4810066223145) --X2
writeDouble('[VehicleCoordinates]+D0', -1266.28552246094) --Y1
writeDouble('[VehicleCoordinates]+900', -1266.28552246094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 116.924080021855) -- Z1
writeDouble('[VehicleCoordinates]+908', 116.924080021855) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136046
"North of Timefall Farm #2 (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 212.90758372087) --X1
writeDouble('[VehicleCoordinates]+8F8', 212.90758372087) --X2
writeDouble('[VehicleCoordinates]+D0', -1322.76818123451) --Y1
writeDouble('[VehicleCoordinates]+900', -1322.76818123451) -- Y2
writeDouble('[VehicleCoordinates]+D8', 110.773302238177) -- Z1
writeDouble('[VehicleCoordinates]+908', 110.773302238177) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136047
"North of Timefall Farm #3 (East Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 286.290642498279) --X1
writeDouble('[VehicleCoordinates]+8F8', 286.290642498279) --X2
writeDouble('[VehicleCoordinates]+D0', -1225.44865830959) --Y1
writeDouble('[VehicleCoordinates]+900', -1225.44865830959) -- Y2
writeDouble('[VehicleCoordinates]+D8', 103.500809471737) -- Z1
writeDouble('[VehicleCoordinates]+908', 103.500809471737) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136048
"East of Distribution Center North of Mountain Knot City (NorthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -852.131401307823) --X1
writeDouble('[VehicleCoordinates]+8F8', -852.131401307823) --X2
writeDouble('[VehicleCoordinates]+D0', 1921.13070426408) --Y1
writeDouble('[VehicleCoordinates]+900', 1921.13070426408) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.012044045121) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.012044045121) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136049
"East of Distribution Center North of Mountain Knot City (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -762.880743824688) --X1
writeDouble('[VehicleCoordinates]+8F8', -762.880743824688) --X2
writeDouble('[VehicleCoordinates]+D0', 1811.14760256781) --Y1
writeDouble('[VehicleCoordinates]+900', 1811.14760256781) -- Y2
writeDouble('[VehicleCoordinates]+D8', 223.408607687459) -- Z1
writeDouble('[VehicleCoordinates]+908', 223.408607687459) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136050
"West of Mountaineer #1 (NorthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1549.63763756896) --X1
writeDouble('[VehicleCoordinates]+8F8', -1549.63763756896) --X2
writeDouble('[VehicleCoordinates]+D0', 1279.34696475638) --Y1
writeDouble('[VehicleCoordinates]+900', 1279.34696475638) -- Y2
writeDouble('[VehicleCoordinates]+D8', 240.661286312599) -- Z1
writeDouble('[VehicleCoordinates]+908', 240.661286312599) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136051
"West of Mountaineer #2 (South/Center Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1698.36560058594) --X1
writeDouble('[VehicleCoordinates]+8F8', -1698.36560058594) --X2
writeDouble('[VehicleCoordinates]+D0', 1087.97488277915) --Y1
writeDouble('[VehicleCoordinates]+900', 1087.97488277915) -- Y2
writeDouble('[VehicleCoordinates]+D8', 219.390731680823) -- Z1
writeDouble('[VehicleCoordinates]+908', 219.390731680823) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136052
"West of Mountaineer #3 (NorthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2031.99719238281) --X1
writeDouble('[VehicleCoordinates]+8F8', -2031.99719238281) --X2
writeDouble('[VehicleCoordinates]+D0', 1277.17714151068) --Y1
writeDouble('[VehicleCoordinates]+900', 1277.17714151068) -- Y2
writeDouble('[VehicleCoordinates]+D8', 222.56957095333) -- Z1
writeDouble('[VehicleCoordinates]+908', 222.56957095333) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136053
"West of Paleontologist #1 (North Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1970.29462433288) --X1
writeDouble('[VehicleCoordinates]+8F8', -1970.29462433288) --X2
writeDouble('[VehicleCoordinates]+D0', -1226.92988345318) --Y1
writeDouble('[VehicleCoordinates]+900', -1226.92988345318) -- Y2
writeDouble('[VehicleCoordinates]+D8', 317.755384444125) -- Z1
writeDouble('[VehicleCoordinates]+908', 317.755384444125) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136054
"West of Paleontologist #2 (SouthEast Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1886.37829589844) --X1
writeDouble('[VehicleCoordinates]+8F8', -1886.37829589844) --X2
writeDouble('[VehicleCoordinates]+D0', -1422.99836564608) --Y1
writeDouble('[VehicleCoordinates]+900', -1422.99836564608) -- Y2
writeDouble('[VehicleCoordinates]+D8', 316.825536068178) -- Z1
writeDouble('[VehicleCoordinates]+908', 316.825536068178) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136055
"West of Paleontologist #3 (SouthWest Postbox)"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2031.86502385937) --X1
writeDouble('[VehicleCoordinates]+8F8', -2031.86502385937) --X2
writeDouble('[VehicleCoordinates]+D0', -1494.35781756771) --Y1
writeDouble('[VehicleCoordinates]+900', -1494.35781756771) -- Y2
writeDouble('[VehicleCoordinates]+D8', 285.722850381182) -- Z1
writeDouble('[VehicleCoordinates]+908', 285.722850381182) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136056
"Hot Springs"
1
136057
"Player"
1
136058
"Central Region"
1
136059
"The Northeastern Healing Spring"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1340.466309)
writeFloat('[PlayerCoordinates]+84', 1288.383301)
writeFloat('[PlayerCoordinates]+88', 182.5351105)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136060
"The Crater Digestive Bath"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1731.767578)
writeFloat('[PlayerCoordinates]+84', -99.78659821)
writeFloat('[PlayerCoordinates]+88', 133.0311279)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136061
"World's End Miracle Pool"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2254.47998)
writeFloat('[PlayerCoordinates]+84', 950.5306396)
writeFloat('[PlayerCoordinates]+88', 213.2780762)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136062
"The Hidden Valley Digestive Bath"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1412.829468)
writeFloat('[PlayerCoordinates]+84', 43.66280365)
writeFloat('[PlayerCoordinates]+88', 360.8777466)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136063
"The Falling Snows Invigorating Waters"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -534.6016235)
writeFloat('[PlayerCoordinates]+84', -135.2055206)
writeFloat('[PlayerCoordinates]+88', 545.9819336)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136064
"The Heartwarming Spa"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1192.753662)
writeFloat('[PlayerCoordinates]+84', -233.138031)
writeFloat('[PlayerCoordinates]+88', 539.5395508)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136065
"The Recharging Spring"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1840.82019)
writeFloat('[PlayerCoordinates]+84', -832.0254517)
writeFloat('[PlayerCoordinates]+88', 389.4522705)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136066
"Vehicle"
1
136067
"Central Region"
1
136068
"The Northeastern Healing Spring"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1339.7134750128) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1339.7134750128) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',1281.3366829037) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',1281.3366829037) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',181.80118412958) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',181.80118412958) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136069
"The Crater Digestive Bath"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',1739.5397949219) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',1739.5397949219) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-107.90338796815) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-107.90338796815) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',130.47675201872) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',130.47675201872) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136070
"World's End Miracle Pool"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-2247.8695003616) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-2247.8695003616) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',943.14053506586) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',943.14053506586) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',211.44186332225) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',211.44186332225) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136071
"The Hidden Valley Digestive Bath"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1407.8285775594) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1407.8285775594) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',35.769364157802) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',35.769364157802) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',359.23476202815) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',359.23476202815) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136072
"The Falling Snows Invigorating Waters"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-548.61670527262) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-548.61670527262) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-132.89735840248) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-132.89735840248) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',546.60176559867) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',546.60176559867) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136073
"The Heartwarming Spa"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1192.0837578053) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1192.0837578053) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-234.29205322266) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-234.29205322266) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',538.29813084491) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',538.29813084491) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136074
"The Recharging Spring"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1834.3568862893) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1834.3568862893) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',-831.33782043604) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',-831.33782043604) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',387.38759193365) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',387.38759193365) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136075
"Memory Chip Locations"
1
136076
"Player"
1
136077
"Eastern Region"
1
136078
"Memory Chip 1 - Frame Arms: Byakko"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 305.3226013)
writeFloat('[PlayerCoordinates]+84', 1109.664429)
writeFloat('[PlayerCoordinates]+88', 158.6854248)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136079
"Memory Chip 2 - Frame Arms Girls: Byakko"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1526.256348)
writeFloat('[PlayerCoordinates]+84', 648.0244751)
writeFloat('[PlayerCoordinates]+88', 207.1336517)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136080
"Memory Chip 15 - Big Fish"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2061.078125)
writeFloat('[PlayerCoordinates]+84', -633.9224243)
writeFloat('[PlayerCoordinates]+88', 156.3375244)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136081
"Memory Chip 18 - The Seven Samurai"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -522.343689)
writeFloat('[PlayerCoordinates]+84', -59.92718887)
writeFloat('[PlayerCoordinates]+88', 248.2678375)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136082
"Memory Chip 41 - Death Stranding/Low Roar"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1734.271362)
writeFloat('[PlayerCoordinates]+84', -523.2963257)
writeFloat('[PlayerCoordinates]+88', 146.0898895)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136083
"Memory Chip 42 - Lucio Fulci’s Horror & Thriller Compilation"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 464.7811584)
writeFloat('[PlayerCoordinates]+84', 232.5404968)
writeFloat('[PlayerCoordinates]+88', 249.9402924)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136084
"Memory Chip 43 - Profondo Rosso Original Motion Picture Soundtrack"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1601.461914)
writeFloat('[PlayerCoordinates]+84', 1007.476196)
writeFloat('[PlayerCoordinates]+88', 149.9267578)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136085
"Memory Chip 45 - dawn/SILENT POETS"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1344.4610595703) -- X Coord
writeFloat('[PlayerCoordinates]+84',-23.613605499268) -- Y Coord
writeFloat('[PlayerCoordinates]+88',287.42327880859) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136086
"Memory Chip 49 - God of War Original Video Game Soundtrack"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1035.6492919922) -- X Coord
writeFloat('[PlayerCoordinates]+84',446.87802124023) -- Y Coord
writeFloat('[PlayerCoordinates]+88',249.23272705078) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136087
"Central Region"
1
136088
"Memory Chip 3 - Frame Arms: Kagetora"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2762.211182)
writeFloat('[PlayerCoordinates]+84', 1994.752441)
writeFloat('[PlayerCoordinates]+88', 226.2251282)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136089
"Memory Chip 4 - Frame Arms: Genbu"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 20.12612534)
writeFloat('[PlayerCoordinates]+84', -234.8839417)
writeFloat('[PlayerCoordinates]+88', 295.3948364)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136090
"Memory Chip 5 - Frame Arms: Mingwu"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1037.479004)
writeFloat('[PlayerCoordinates]+84', -949.3127441)
writeFloat('[PlayerCoordinates]+88', 158.2014923)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136091
"Memory Chip 6 - Kotobukiya Ludens Girl Model"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1786.029175)
writeFloat('[PlayerCoordinates]+84', 1939.587891)
writeFloat('[PlayerCoordinates]+88', 239.7809143)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136092
"Memory Chip 7 - Prime 1 Studio 1/2 Scale Ludens Statue"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1044.637451)
writeFloat('[PlayerCoordinates]+84', 618.6408691)
writeFloat('[PlayerCoordinates]+88', 426.966095)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136093
"Memory Chip 8 - Sentinel 1/6 Ludens Action Figure"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1715.0113525391) -- X Coord
writeFloat('[PlayerCoordinates]+84',389.47662353516) -- Y Coord
writeFloat('[PlayerCoordinates]+88',272.96578979492) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136094
"Memory Chip 9 - Max Factory Ludens figma"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1672.410522)
writeFloat('[PlayerCoordinates]+84', -1227.48645)
writeFloat('[PlayerCoordinates]+88', 129.5138397)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136095
"Memory Chip 11 - Christine"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1850.883423)
writeFloat('[PlayerCoordinates]+84', 799.9724731)
writeFloat('[PlayerCoordinates]+88', 194.0888214)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136096
"Memory Chip 12 - Godzilla"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1194.658325)
writeFloat('[PlayerCoordinates]+84', 180.8851318)
writeFloat('[PlayerCoordinates]+88', 351.3838501)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136097
"Memory Chip 13 - The Walk"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -260.7485657)
writeFloat('[PlayerCoordinates]+84', 764.059082)
writeFloat('[PlayerCoordinates]+88', 836.0373535)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136098
"Memory Chip 14 - Stand By Me"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -351.7303467)
writeFloat('[PlayerCoordinates]+84', 2291.748779)
writeFloat('[PlayerCoordinates]+88', 228.4796753)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136099
"Memory Chip 16 - Fright Night"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 887.1785889)
writeFloat('[PlayerCoordinates]+84', 1807.272461)
writeFloat('[PlayerCoordinates]+88', 173.8918304)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136100
"Memory Chip 17 - Matango"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2184.953125)
writeFloat('[PlayerCoordinates]+84', 503.3970032)
writeFloat('[PlayerCoordinates]+88', 174.6264038)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136101
"Memory Chip 19 - The Bridge on the River Kwai"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 645.4030151)
writeFloat('[PlayerCoordinates]+84', -1224.511597)
writeFloat('[PlayerCoordinates]+88', 82.30245972)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136102
"Memory Chip 20 - Dr. Strangelove"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1048.530151)
writeFloat('[PlayerCoordinates]+84', -339.1749573)
writeFloat('[PlayerCoordinates]+88', 495.9084473)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136103
"Memory Chip 21 - Eggshell Carving"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2446.21875)
writeFloat('[PlayerCoordinates]+84', 1385.121094)
writeFloat('[PlayerCoordinates]+88', 189.335495)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136489
"Memory Chip 22 - Glasscraft"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1681.7547607422) -- X Coord
writeFloat('[PlayerCoordinates]+84',1318.5885009766) -- Y Coord
writeFloat('[PlayerCoordinates]+88',175.060546875) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136105
"Memory Chip 23 - Coffee Cup"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 338.1799316)
writeFloat('[PlayerCoordinates]+84', -1230.550659)
writeFloat('[PlayerCoordinates]+88', 104.4452591)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136106
"Memory Chip 24 - Soap Bubble"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 85.89586639)
writeFloat('[PlayerCoordinates]+84', -1589.502197)
writeFloat('[PlayerCoordinates]+88', 125.0923767)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136107
"Memory Chip 25 - Frozen Soap Bubble"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1276.22168)
writeFloat('[PlayerCoordinates]+84', -222.9790649)
writeFloat('[PlayerCoordinates]+88', 591.480957)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136108
"Memory Chip 26 - Dandelion Seeds"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -448.8872681)
writeFloat('[PlayerCoordinates]+84', 560.1846313)
writeFloat('[PlayerCoordinates]+88', 706.6471558)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136109
"Memory Chip 27 - Wine Glass"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1245.559082)
writeFloat('[PlayerCoordinates]+84', 958.6608276)
writeFloat('[PlayerCoordinates]+88', 449.2102051)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136110
"Memory Chip 28 - Pottery"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1126.537354)
writeFloat('[PlayerCoordinates]+84', -1102.964478)
writeFloat('[PlayerCoordinates]+88', 160.5681)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136111
"Memory Chip 29 - Snow Crystal"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1009.758545)
writeFloat('[PlayerCoordinates]+84', 163.1565247)
writeFloat('[PlayerCoordinates]+88', 456.9030762)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136112
"Memory Chip 30 - Fused Silica"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1370.215332)
writeFloat('[PlayerCoordinates]+84', -1339.221191)
writeFloat('[PlayerCoordinates]+88', 339.9326477)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136113
"Memory Chip 31 - Reverse Trike: "Ride" Type"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',465.96322631836) -- X Coord
writeFloat('[PlayerCoordinates]+84',-859.97082519531) -- Y Coord
writeFloat('[PlayerCoordinates]+88',102.04444122314) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136114
"Memory Chip 32 - Honda NSR250R"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1624.102661)
writeFloat('[PlayerCoordinates]+84', 1045.278076)
writeFloat('[PlayerCoordinates]+88', 176.3342285)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136115
"Memory Chip 33 - Honda Rebel 500"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 11.00675392)
writeFloat('[PlayerCoordinates]+84', -1250.198975)
writeFloat('[PlayerCoordinates]+88', 122.8499985)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136116
"Memory Chip 34 - Triumph Bonneville Bobber"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1459.526001)
writeFloat('[PlayerCoordinates]+84', 186.265152)
writeFloat('[PlayerCoordinates]+88', 134.6276855)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136117
"Memory Chip 35 - Triumph Street Triple RS"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1639.299683)
writeFloat('[PlayerCoordinates]+84', -297.3280945)
writeFloat('[PlayerCoordinates]+88', 138.3884888)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136118
"Memory Chip 36 - Yamaha MT-09"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',572.68743896484) -- X Coord
writeFloat('[PlayerCoordinates]+84',884.79681396484) -- Y Coord
writeFloat('[PlayerCoordinates]+88',170.16705322266) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136119
"Memory Chip 37 - Yamaha RD500LC"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -722.5377197)
writeFloat('[PlayerCoordinates]+84', 1792.618286)
writeFloat('[PlayerCoordinates]+88', 224.4454193)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136120
"Memory Chip 38 - Kawasaki Z1 (900 Super Four)"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1695.2076416016) -- X Coord
writeFloat('[PlayerCoordinates]+84',1256.111328125) -- Y Coord
writeFloat('[PlayerCoordinates]+88',222.83842468262) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136121
"Memory Chip 39 - Kawasaki Ninja H2R"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1911.68042)
writeFloat('[PlayerCoordinates]+84', -1411.432129)
writeFloat('[PlayerCoordinates]+88', 317.8957825)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136122
"Memory Chip 44 - Thelma Original Motion Picture Soundtrack"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 670.0088501)
writeFloat('[PlayerCoordinates]+84', 1501.601318)
writeFloat('[PlayerCoordinates]+88', 172.663147)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136123
"Memory Chip 46 - Low Roar/Low Roar"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 25.40239716)
writeFloat('[PlayerCoordinates]+84', -967.6439209)
writeFloat('[PlayerCoordinates]+88', 127.9529419)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136124
"Memory Chip 47 - 0/Low Roar"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2618.421387)
writeFloat('[PlayerCoordinates]+84', 1676.081909)
writeFloat('[PlayerCoordinates]+88', 188.8448486)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136125
"Memory Chip 48 - Once In A Long, Long While…/Low Roar"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2098.852295)
writeFloat('[PlayerCoordinates]+84', 288.4703064)
writeFloat('[PlayerCoordinates]+88', 154.211792)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136126
"Memory Chip 50 - Bronson Soundtrack"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -108.3263321)
writeFloat('[PlayerCoordinates]+84', 1789.714233)
writeFloat('[PlayerCoordinates]+88', 294.3502197)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136127
"Memory Chip 51 - Valhalla Rising: Original Soundtrack by Peter Peter & Peter Kyed"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 403.8961792)
writeFloat('[PlayerCoordinates]+84', -2104.087891)
writeFloat('[PlayerCoordinates]+88', 284.1140442)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136128
"Memory Chip 52 - Nicolas Winding Refn The Wicked Die Young"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -915.0614014)
writeFloat('[PlayerCoordinates]+84', 79.17208099)
writeFloat('[PlayerCoordinates]+88', 487.6524658)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136129
"Memory Chip 54 - An Unknown Man's Journal Part 1"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1237.696655)
writeFloat('[PlayerCoordinates]+84', 1677.309448)
writeFloat('[PlayerCoordinates]+88', 194.8792267)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136130
"Memory Chip 55 - An Unknown Man's Journal Part 2"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',1189.2738037109) -- X Coord
writeFloat('[PlayerCoordinates]+84',-622.20397949219) -- Y Coord
writeFloat('[PlayerCoordinates]+88',142.57870483398) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136131
"Memory Chip 56 - An Unknown Man's Journal Part 3"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1782.747681)
writeFloat('[PlayerCoordinates]+84', 1964.137573)
writeFloat('[PlayerCoordinates]+88', 204.5719604)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136132
"Western Region"
1
136133
"Memory Chip 10 - Good Smile Company Nendoroid Jumbo Ludens"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -633.8301392)
writeFloat('[PlayerCoordinates]+84', 120.0190582)
writeFloat('[PlayerCoordinates]+88', 99.559226989746)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136134
"Memory Chip 40 - Harley-Davidson Pan America 1250"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -91.27903748)
writeFloat('[PlayerCoordinates]+84', 858.9177246)
writeFloat('[PlayerCoordinates]+88', 109.5956421)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136135
"Memory Chip 53 - My Life Directed By Nicolas Winding Refn"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -480.1652527)
writeFloat('[PlayerCoordinates]+84', 486.0870056)
writeFloat('[PlayerCoordinates]+88', 110.5067673)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136136
"Road Pavers"
1
136137
"Central Region"
1
136138
"Player"
1
136139
"Auto-Paver UC Route 23-1"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2453.14624)
writeFloat('[PlayerCoordinates]+84', 1699.640625)
writeFloat('[PlayerCoordinates]+88', 211.4180145)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136140
"Auto-Paver UC Route 23-2"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 2311.13623)
writeFloat('[PlayerCoordinates]+84', 1403.849365)
writeFloat('[PlayerCoordinates]+88', 186.8805084)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136141
"Auto-Paver UC Route 23-3"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1985.889404)
writeFloat('[PlayerCoordinates]+84', 1407.069824)
writeFloat('[PlayerCoordinates]+88', 169.5019684)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136142
"Auto-Paver UC Route 23-4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1829.855713)
writeFloat('[PlayerCoordinates]+84', 1440.04834)
writeFloat('[PlayerCoordinates]+88', 170.9070892)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136143
"Auto-Paver UC Route 23-5"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1618.688354)
writeFloat('[PlayerCoordinates]+84', 1312.620972)
writeFloat('[PlayerCoordinates]+88', 168.8905792)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136144
"Auto-Paver UC Route 23-6"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1377.54895)
writeFloat('[PlayerCoordinates]+84', 1200.65271)
writeFloat('[PlayerCoordinates]+88', 179.8018036)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136145
"Auto-Paver UC Route 23-7"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1288.580444)
writeFloat('[PlayerCoordinates]+84', 957.550293)
writeFloat('[PlayerCoordinates]+88', 169.3945465)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136146
"Auto-Paver UC Route 23-8"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1247.076904)
writeFloat('[PlayerCoordinates]+84', 837.4451294)
writeFloat('[PlayerCoordinates]+88', 166.352829)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136147
"Auto-Paver UC Route 23-9"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1116.213745)
writeFloat('[PlayerCoordinates]+84', 654.8239746)
writeFloat('[PlayerCoordinates]+88', 173.6411743)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136148
"Auto-Paver UC Route 23-10"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 970.8752441)
writeFloat('[PlayerCoordinates]+84', 362.0913391)
writeFloat('[PlayerCoordinates]+88', 155.4854889)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136149
"Auto-Paver UC Route 23-11"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 862.5824585)
writeFloat('[PlayerCoordinates]+84', 97.48329926)
writeFloat('[PlayerCoordinates]+88', 154.0669098)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136150
"Auto-Paver UC Route 23-12"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 713.2119751)
writeFloat('[PlayerCoordinates]+84', -62.8556633)
writeFloat('[PlayerCoordinates]+88', 158.2936554)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136151
"Auto-Paver UC Route 23-13"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 712.274231)
writeFloat('[PlayerCoordinates]+84', -206.9367676)
writeFloat('[PlayerCoordinates]+88', 153.6023254)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136152
"Auto-Paver UC Route 23-14"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 798.9649048)
writeFloat('[PlayerCoordinates]+84', -448.7363892)
writeFloat('[PlayerCoordinates]+88', 156.8727264)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136153
"Auto-Paver UC Route 23-15"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 843.2941895)
writeFloat('[PlayerCoordinates]+84', -719.6339722)
writeFloat('[PlayerCoordinates]+88', 172.478302)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136154
"Auto-Paver UC Route 23-16"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1003.420654)
writeFloat('[PlayerCoordinates]+84', -755.526123)
writeFloat('[PlayerCoordinates]+88', 153.5244446)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136155
"Auto-Paver UC Route 23-17"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1104.900024)
writeFloat('[PlayerCoordinates]+84', -851.0733643)
writeFloat('[PlayerCoordinates]+88', 152.1719818)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136156
"Auto-Paver UC Route 23-18"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1255.769287)
writeFloat('[PlayerCoordinates]+84', -1001.83905)
writeFloat('[PlayerCoordinates]+88', 148.2466431)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136157
"Auto-Paver UC Route 41-1"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 1146.322388)
writeFloat('[PlayerCoordinates]+84', 1195.00061)
writeFloat('[PlayerCoordinates]+88', 178.6529694)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136158
"Auto-Paver UC Route 41-2"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 846.9970093)
writeFloat('[PlayerCoordinates]+84', 1286.466309)
writeFloat('[PlayerCoordinates]+88', 180.8608704)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136159
"Auto-Paver UC Route 41-3"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 470.3439941)
writeFloat('[PlayerCoordinates]+84', 1481.882324)
writeFloat('[PlayerCoordinates]+88', 174.1802368)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136160
"Auto-Paver UC Route 41-4"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 490.9615173)
writeFloat('[PlayerCoordinates]+84', 1638.019897)
writeFloat('[PlayerCoordinates]+88', 173.9845428)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136161
"Auto-Paver UC Route 41-5"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 359.7417908)
writeFloat('[PlayerCoordinates]+84', 1903.619873)
writeFloat('[PlayerCoordinates]+88', 178.6823578)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136162
"Auto-Paver UC Route 41-6"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', 39.72900772)
writeFloat('[PlayerCoordinates]+84', 1990.067627)
writeFloat('[PlayerCoordinates]+88', 210.7412415)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136163
"Auto-Paver UC Route 41-7"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -195.2884827)
writeFloat('[PlayerCoordinates]+84', 2135.605713)
writeFloat('[PlayerCoordinates]+88', 213.7081757)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136164
"Auto-Paver UC Route 41-8"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -558.8688354)
writeFloat('[PlayerCoordinates]+84', 2285.988281)
writeFloat('[PlayerCoordinates]+88', 257.3166504)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136165
"Auto-Paver UC Route 41-9"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -792.6043091)
writeFloat('[PlayerCoordinates]+84', 2166.758057)
writeFloat('[PlayerCoordinates]+88', 263.3792419)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136166
"Auto-Paver UC Route 41-10"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1160.645386)
writeFloat('[PlayerCoordinates]+84', 2036.688843)
writeFloat('[PlayerCoordinates]+88', 229.9067688)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136167
"Auto-Paver UC Route 41-11"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1361.537842)
writeFloat('[PlayerCoordinates]+84', 2076.553955)
writeFloat('[PlayerCoordinates]+88', 221.8985901)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136168
"Auto-Paver UC Route 41-12"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1547.109131)
writeFloat('[PlayerCoordinates]+84', 1935.644165)
writeFloat('[PlayerCoordinates]+88', 224.309845)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136169
"Auto-Paver UC Route 41-13"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1907.11731)
writeFloat('[PlayerCoordinates]+84', 1876.725098)
writeFloat('[PlayerCoordinates]+88', 236.8751526)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136170
"Auto-Paver UC Route 41-14"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -2025.526367)
writeFloat('[PlayerCoordinates]+84', 1640.04895)
writeFloat('[PlayerCoordinates]+88', 229.2415161)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136171
"Auto-Paver UC Route 41-15"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1895.238647)
writeFloat('[PlayerCoordinates]+84', 1490.789062)
writeFloat('[PlayerCoordinates]+88', 223.1715546)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136172
"Auto-Paver UC Route 41-16"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1906.622314)
writeFloat('[PlayerCoordinates]+84', 1354.921143)
writeFloat('[PlayerCoordinates]+88', 221.3041687)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136173
"Auto-Paver UC Route 41-17"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1943.136719)
writeFloat('[PlayerCoordinates]+84', 1120.62561)
writeFloat('[PlayerCoordinates]+88', 218.1954651)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136174
"Auto-Paver UC Route 41-18"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1780.78418)
writeFloat('[PlayerCoordinates]+84', 939.0974731)
writeFloat('[PlayerCoordinates]+88', 223.4832611)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136175
"Auto-Paver UC Route 41-19"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1784.200562)
writeFloat('[PlayerCoordinates]+84', 682.1999512)
writeFloat('[PlayerCoordinates]+88', 240.7770233)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136176
"Auto-Paver UC Route 41-20"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1761.403687)
writeFloat('[PlayerCoordinates]+84', 326.7902527)
writeFloat('[PlayerCoordinates]+88', 273.279541)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136177
"Auto-Paver UC Route 41-21"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1586.323608)
writeFloat('[PlayerCoordinates]+84', 379.0655823)
writeFloat('[PlayerCoordinates]+88', 300.0988464)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136178
"Auto-Paver UC Route 41-22"
Auto Assembler Script
[enable]
{$lua}
writeFloat('[PlayerCoordinates]+80', -1217.474854)
writeFloat('[PlayerCoordinates]+84', 292.9422302)
writeFloat('[PlayerCoordinates]+88', 363.2103271)
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136179
"Auto-Paver UC Route 41-23"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-1187.0806884766) -- X Coord
writeFloat('[PlayerCoordinates]+84',448.60034179688) -- Y Coord
writeFloat('[PlayerCoordinates]+88',382.45858764648) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136180
"Auto-Paver UC Route 41-24"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-957.986328125) -- X Coord
writeFloat('[PlayerCoordinates]+84',381.91415405273) -- Y Coord
writeFloat('[PlayerCoordinates]+88',444.57873535156) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136181
"Auto-Paver UC Route 41-25"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-788.24206542969) -- X Coord
writeFloat('[PlayerCoordinates]+84',405.96148681641) -- Y Coord
writeFloat('[PlayerCoordinates]+88',479.97555541992) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136182
"Auto-Paver UC Route 41-26"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-466.52941894531) -- X Coord
writeFloat('[PlayerCoordinates]+84',274.6549987793) -- Y Coord
writeFloat('[PlayerCoordinates]+88',559.29931640625) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136183
"Auto-Paver UC Route 41-27"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',-256.97659301758) -- X Coord
writeFloat('[PlayerCoordinates]+84',277.44952392578) -- Y Coord
writeFloat('[PlayerCoordinates]+88',510.40487670898) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136184
"Auto-Paver UC Route 41-28"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',172.89840698242) -- X Coord
writeFloat('[PlayerCoordinates]+84',515.01354980469) -- Y Coord
writeFloat('[PlayerCoordinates]+88',417.17828369141) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136185
"Auto-Paver UC Route 41-29"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',153.07804870605) -- X Coord
writeFloat('[PlayerCoordinates]+84',206.49270629883) -- Y Coord
writeFloat('[PlayerCoordinates]+88',313.49258422852) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136186
"Auto-Paver UC Route 41-30"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',393.99450683594) -- X Coord
writeFloat('[PlayerCoordinates]+84',132.54885864258) -- Y Coord
writeFloat('[PlayerCoordinates]+88',222.07008361816) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136187
"Auto-Paver UC Route 41-31"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',618.18829345703) -- X Coord
writeFloat('[PlayerCoordinates]+84',508.34286499023) -- Y Coord
writeFloat('[PlayerCoordinates]+88',185.087890625) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136188
"Auto-Paver UC Route 41-32"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',709.70568847656) -- X Coord
writeFloat('[PlayerCoordinates]+84',605.64715576172) -- Y Coord
writeFloat('[PlayerCoordinates]+88',170.54331970215) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136189
"Auto-Paver UC Route 41-33"
Auto Assembler Script
{$lua}
[ENABLE]
writeFloat('[PlayerCoordinates]+80',768.94732666016) -- X Coord
writeFloat('[PlayerCoordinates]+84',527.00286865234) -- Y Coord
writeFloat('[PlayerCoordinates]+88',159.05082702637) -- Z Coord
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136190
"Vehicle"
1
136191
"Auto-Paver UC Route 23-1"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2442.0808190761) --X1
writeDouble('[VehicleCoordinates]+8F8', 2442.0808190761) --X2
writeDouble('[VehicleCoordinates]+D0', 1704.68666043396) --Y1
writeDouble('[VehicleCoordinates]+900', 1704.68666043396) -- Y2
writeDouble('[VehicleCoordinates]+D8', 210.021445795168) -- Z1
writeDouble('[VehicleCoordinates]+908', 210.021445795168) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136192
"Auto-Paver UC Route 23-2"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 2317.23063883206) --X1
writeDouble('[VehicleCoordinates]+8F8', 2317.23063883206) --X2
writeDouble('[VehicleCoordinates]+D0', 1398.79102660746) --Y1
writeDouble('[VehicleCoordinates]+900', 1398.79102660746) -- Y2
writeDouble('[VehicleCoordinates]+D8', 184.864189992258) -- Z1
writeDouble('[VehicleCoordinates]+908', 184.864189992258) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136193
"Auto-Paver UC Route 23-3"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1986.04507356329) --X1
writeDouble('[VehicleCoordinates]+8F8', 1986.04507356329) --X2
writeDouble('[VehicleCoordinates]+D0', 1417.87097167969) --Y1
writeDouble('[VehicleCoordinates]+900', 1417.87097167969) -- Y2
writeDouble('[VehicleCoordinates]+D8', 167.819427490234) -- Z1
writeDouble('[VehicleCoordinates]+908', 167.819427490234) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136194
"Auto-Paver UC Route 23-4"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1832.73596278671) --X1
writeDouble('[VehicleCoordinates]+8F8', 1832.73596278671) --X2
writeDouble('[VehicleCoordinates]+D0', 1452.07067871094) --Y1
writeDouble('[VehicleCoordinates]+900', 1452.07067871094) -- Y2
writeDouble('[VehicleCoordinates]+D8', 169.744624355255) -- Z1
writeDouble('[VehicleCoordinates]+908', 169.744624355255) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136195
"Auto-Paver UC Route 23-5"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1625.62109456806) --X1
writeDouble('[VehicleCoordinates]+8F8', 1625.62109456806) --X2
writeDouble('[VehicleCoordinates]+D0', 1314.66109266777) --Y1
writeDouble('[VehicleCoordinates]+900', 1314.66109266777) -- Y2
writeDouble('[VehicleCoordinates]+D8', 166.498027620692) -- Z1
writeDouble('[VehicleCoordinates]+908', 166.498027620692) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136196
"Auto-Paver UC Route 23-6"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1379.1860932167) --X1
writeDouble('[VehicleCoordinates]+8F8', 1379.1860932167) --X2
writeDouble('[VehicleCoordinates]+D0', 1212.33807472204) --Y1
writeDouble('[VehicleCoordinates]+900', 1212.33807472204) -- Y2
writeDouble('[VehicleCoordinates]+D8', 178.047237210321) -- Z1
writeDouble('[VehicleCoordinates]+908', 178.047237210321) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136197
"Auto-Paver UC Route 23-7"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1279.35766601563) --X1
writeDouble('[VehicleCoordinates]+8F8', 1279.35766601563) --X2
writeDouble('[VehicleCoordinates]+D0', 958.328399267764) --Y1
writeDouble('[VehicleCoordinates]+900', 958.328399267764) -- Y2
writeDouble('[VehicleCoordinates]+D8', 167.982704650646) -- Z1
writeDouble('[VehicleCoordinates]+908', 167.982704650646) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136198
"Auto-Paver UC Route 23-8"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1239.14562988281) --X1
writeDouble('[VehicleCoordinates]+8F8', 1239.14562988281) --X2
writeDouble('[VehicleCoordinates]+D0', 841.346497278864) --Y1
writeDouble('[VehicleCoordinates]+900', 841.346497278864) -- Y2
writeDouble('[VehicleCoordinates]+D8', 164.825652727755) -- Z1
writeDouble('[VehicleCoordinates]+908', 164.825652727755) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136199
"Auto-Paver UC Route 23-9"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1107.67634006451) --X1
writeDouble('[VehicleCoordinates]+8F8', 1107.67634006451) --X2
writeDouble('[VehicleCoordinates]+D0', 661.34481472908) --Y1
writeDouble('[VehicleCoordinates]+900', 661.34481472908) -- Y2
writeDouble('[VehicleCoordinates]+D8', 171.902974790855) -- Z1
writeDouble('[VehicleCoordinates]+908', 171.902974790855) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136200
"Auto-Paver UC Route 23-10"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 959.101870486069) --X1
writeDouble('[VehicleCoordinates]+8F8', 959.101870486069) --X2
writeDouble('[VehicleCoordinates]+D0', 365.98756619463) --Y1
writeDouble('[VehicleCoordinates]+900', 365.98756619463) -- Y2
writeDouble('[VehicleCoordinates]+D8', 153.925854788254) -- Z1
writeDouble('[VehicleCoordinates]+908', 153.925854788254) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136201
"Auto-Paver UC Route 23-11"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 855.001037597656) --X1
writeDouble('[VehicleCoordinates]+8F8', 855.001037597656) --X2
writeDouble('[VehicleCoordinates]+D0', 103.919731031745) --Y1
writeDouble('[VehicleCoordinates]+900', 103.919731031745) -- Y2
writeDouble('[VehicleCoordinates]+D8', 152.482773043932) -- Z1
writeDouble('[VehicleCoordinates]+908', 152.482773043932) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136202
"Auto-Paver UC Route 23-12"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 702.134460449219) --X1
writeDouble('[VehicleCoordinates]+8F8', 702.134460449219) --X2
writeDouble('[VehicleCoordinates]+D0', -63.9743050782479) --Y1
writeDouble('[VehicleCoordinates]+900', -63.9743050782479) -- Y2
writeDouble('[VehicleCoordinates]+D8', 157.122079353043) -- Z1
writeDouble('[VehicleCoordinates]+908', 157.122079353043) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136203
"Auto-Paver UC Route 23-13"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 702.471984863281) --X1
writeDouble('[VehicleCoordinates]+8F8', 702.471984863281) --X2
writeDouble('[VehicleCoordinates]+D0', -208.011706038022) --Y1
writeDouble('[VehicleCoordinates]+900', -208.011706038022) -- Y2
writeDouble('[VehicleCoordinates]+D8', 152.124013696801) -- Z1
writeDouble('[VehicleCoordinates]+908', 152.124013696801) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136204
"Auto-Paver UC Route 23-14"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 794.752228252051) --X1
writeDouble('[VehicleCoordinates]+8F8', 794.752228252051) --X2
writeDouble('[VehicleCoordinates]+D0', -460.084596395936) --Y1
writeDouble('[VehicleCoordinates]+900', -460.084596395936) -- Y2
writeDouble('[VehicleCoordinates]+D8', 155.509546968079) -- Z1
writeDouble('[VehicleCoordinates]+908', 155.509546968079) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136205
"Auto-Paver UC Route 23-15"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 834.292724609375) --X1
writeDouble('[VehicleCoordinates]+8F8', 834.292724609375) --X2
writeDouble('[VehicleCoordinates]+D0', -725.231201171875) --Y1
writeDouble('[VehicleCoordinates]+900', -725.231201171875) -- Y2
writeDouble('[VehicleCoordinates]+D8', 171.096970639053) -- Z1
writeDouble('[VehicleCoordinates]+908', 171.096970639053) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136206
"Auto-Paver UC Route 23-16"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 996.869692327011) --X1
writeDouble('[VehicleCoordinates]+8F8', 996.869692327011) --X2
writeDouble('[VehicleCoordinates]+D0', -764.42067623233) --Y1
writeDouble('[VehicleCoordinates]+900', -764.42067623233) -- Y2
writeDouble('[VehicleCoordinates]+D8', 152.068341498099) -- Z1
writeDouble('[VehicleCoordinates]+908', 152.068341498099) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136207
"Auto-Paver UC Route 23-17"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1096.42126464844) --X1
writeDouble('[VehicleCoordinates]+8F8', 1096.42126464844) --X2
writeDouble('[VehicleCoordinates]+D0', -854.691314397453) --Y1
writeDouble('[VehicleCoordinates]+900', -854.691314397453) -- Y2
writeDouble('[VehicleCoordinates]+D8', 150.736859994194) -- Z1
writeDouble('[VehicleCoordinates]+908', 150.736859994194) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136208
"Auto-Paver UC Route 23-18"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1251.04479980469) --X1
writeDouble('[VehicleCoordinates]+8F8', 1251.04479980469) --X2
writeDouble('[VehicleCoordinates]+D0', -1008.68579101563) --Y1
writeDouble('[VehicleCoordinates]+900', -1008.68579101563) -- Y2
writeDouble('[VehicleCoordinates]+D8', 146.891348068035) -- Z1
writeDouble('[VehicleCoordinates]+908', 146.891348068035) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136209
"Auto-Paver UC Route 41-1"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 1150.53009154918) --X1
writeDouble('[VehicleCoordinates]+8F8', 1150.53009154918) --X2
writeDouble('[VehicleCoordinates]+D0', 1204.56750488281) --Y1
writeDouble('[VehicleCoordinates]+900', 1204.56750488281) -- Y2
writeDouble('[VehicleCoordinates]+D8', 176.898577959151) -- Z1
writeDouble('[VehicleCoordinates]+908', 176.898577959151) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136210
"Auto-Paver UC Route 41-2"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 851.779824083613) --X1
writeDouble('[VehicleCoordinates]+8F8', 851.779824083613) --X2
writeDouble('[VehicleCoordinates]+D0', 1295.29054208228) --Y1
writeDouble('[VehicleCoordinates]+900', 1295.29054208228) -- Y2
writeDouble('[VehicleCoordinates]+D8', 179.101870769769) -- Z1
writeDouble('[VehicleCoordinates]+908', 179.101870769769) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136211
"Auto-Paver UC Route 41-3"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 480.192383656482) --X1
writeDouble('[VehicleCoordinates]+8F8', 480.192383656482) --X2
writeDouble('[VehicleCoordinates]+D0', 1487.14617751125) --Y1
writeDouble('[VehicleCoordinates]+900', 1487.14617751125) -- Y2
writeDouble('[VehicleCoordinates]+D8', 172.386107432179) -- Z1
writeDouble('[VehicleCoordinates]+908', 172.386107432179) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136212
"Auto-Paver UC Route 41-4"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 500.850250244141) --X1
writeDouble('[VehicleCoordinates]+8F8', 500.850250244141) --X2
writeDouble('[VehicleCoordinates]+D0', 1632.28918457031) --Y1
writeDouble('[VehicleCoordinates]+900', 1632.28918457031) -- Y2
writeDouble('[VehicleCoordinates]+D8', 172.344511785084) -- Z1
writeDouble('[VehicleCoordinates]+908', 172.344511785084) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136213
"Auto-Paver UC Route 41-5"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 366.921743600044) --X1
writeDouble('[VehicleCoordinates]+8F8', 366.921743600044) --X2
writeDouble('[VehicleCoordinates]+D0', 1910.13995512461) --Y1
writeDouble('[VehicleCoordinates]+900', 1910.13995512461) -- Y2
writeDouble('[VehicleCoordinates]+D8', 176.944052196663) -- Z1
writeDouble('[VehicleCoordinates]+908', 176.944052196663) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136214
"Auto-Paver UC Route 41-6"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', 46.3181376829277) --X1
writeDouble('[VehicleCoordinates]+8F8', 46.3181376829277) --X2
writeDouble('[VehicleCoordinates]+D0', 1998.86719017877) --Y1
writeDouble('[VehicleCoordinates]+900', 1998.86719017877) -- Y2
writeDouble('[VehicleCoordinates]+D8', 208.908618400897) -- Z1
writeDouble('[VehicleCoordinates]+908', 208.908618400897) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136215
"Auto-Paver UC Route 41-7"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -193.147800827181) --X1
writeDouble('[VehicleCoordinates]+8F8', -193.147800827181) --X2
writeDouble('[VehicleCoordinates]+D0', 2145.42797851563) --Y1
writeDouble('[VehicleCoordinates]+900', 2145.42797851563) -- Y2
writeDouble('[VehicleCoordinates]+D8', 212.021382065097) -- Z1
writeDouble('[VehicleCoordinates]+908', 212.021382065097) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136216
"Auto-Paver UC Route 41-8"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -566.533782418817) --X1
writeDouble('[VehicleCoordinates]+8F8', -566.533782418817) --X2
writeDouble('[VehicleCoordinates]+D0', 2293.71435546875) --Y1
writeDouble('[VehicleCoordinates]+900', 2293.71435546875) -- Y2
writeDouble('[VehicleCoordinates]+D8', 255.653000418097) -- Z1
writeDouble('[VehicleCoordinates]+908', 255.653000418097) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136217
"Auto-Paver UC Route 41-9"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -799.987031459677) --X1
writeDouble('[VehicleCoordinates]+8F8', -799.987031459677) --X2
writeDouble('[VehicleCoordinates]+D0', 2174.99328422564) --Y1
writeDouble('[VehicleCoordinates]+900', 2174.99328422564) -- Y2
writeDouble('[VehicleCoordinates]+D8', 261.870437860467) -- Z1
writeDouble('[VehicleCoordinates]+908', 261.870437860467) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136218
"Auto-Paver UC Route 41-10"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1161.91052246094) --X1
writeDouble('[VehicleCoordinates]+8F8', -1161.91052246094) --X2
writeDouble('[VehicleCoordinates]+D0', 2046.38586425781) --Y1
writeDouble('[VehicleCoordinates]+900', 2046.38586425781) -- Y2
writeDouble('[VehicleCoordinates]+D8', 228.112930297852) -- Z1
writeDouble('[VehicleCoordinates]+908', 228.112930297852) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136219
"Auto-Paver UC Route 41-11"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1368.24572753906) --X1
writeDouble('[VehicleCoordinates]+8F8', -1368.24572753906) --X2
writeDouble('[VehicleCoordinates]+D0', 2084.41870117188) --Y1
writeDouble('[VehicleCoordinates]+900', 2084.41870117188) -- Y2
writeDouble('[VehicleCoordinates]+D8', 219.990333848073) -- Z1
writeDouble('[VehicleCoordinates]+908', 219.990333848073) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136220
"Auto-Paver UC Route 41-12"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1551.05699141063) --X1
writeDouble('[VehicleCoordinates]+8F8', -1551.05699141063) --X2
writeDouble('[VehicleCoordinates]+D0', 1945.86828613281) --Y1
writeDouble('[VehicleCoordinates]+900', 1945.86828613281) -- Y2
writeDouble('[VehicleCoordinates]+D8', 222.643507149487) -- Z1
writeDouble('[VehicleCoordinates]+908', 222.643507149487) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136221
"Auto-Paver UC Route 41-13"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1912.22619628906) --X1
writeDouble('[VehicleCoordinates]+8F8', -1912.22619628906) --X2
writeDouble('[VehicleCoordinates]+D0', 1885.48229980469) --Y1
writeDouble('[VehicleCoordinates]+900', 1885.48229980469) -- Y2
writeDouble('[VehicleCoordinates]+D8', 235.229557357241) -- Z1
writeDouble('[VehicleCoordinates]+908', 235.229557357241) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136222
"Auto-Paver UC Route 41-14"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -2036.37609863281) --X1
writeDouble('[VehicleCoordinates]+8F8', -2036.37609863281) --X2
writeDouble('[VehicleCoordinates]+D0', 1640.39556648879) --Y1
writeDouble('[VehicleCoordinates]+900', 1640.39556648879) -- Y2
writeDouble('[VehicleCoordinates]+D8', 227.429133007035) -- Z1
writeDouble('[VehicleCoordinates]+908', 227.429133007035) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136223
"Auto-Paver UC Route 41-15"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1902.17590332031) --X1
writeDouble('[VehicleCoordinates]+8F8', -1902.17590332031) --X2
writeDouble('[VehicleCoordinates]+D0', 1483.40588378906) --Y1
writeDouble('[VehicleCoordinates]+900', 1483.40588378906) -- Y2
writeDouble('[VehicleCoordinates]+D8', 221.478233384456) -- Z1
writeDouble('[VehicleCoordinates]+908', 221.478233384456) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136224
"Auto-Paver UC Route 41-16"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1915.9462890625) --X1
writeDouble('[VehicleCoordinates]+8F8', -1915.9462890625) --X2
writeDouble('[VehicleCoordinates]+D0', 1359.74951171875) --Y1
writeDouble('[VehicleCoordinates]+900', 1359.74951171875) -- Y2
writeDouble('[VehicleCoordinates]+D8', 219.26511276731) -- Z1
writeDouble('[VehicleCoordinates]+908', 219.26511276731) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136225
"Auto-Paver UC Route 41-17"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1956.62463337649) --X1
writeDouble('[VehicleCoordinates]+8F8', -1956.62463337649) --X2
writeDouble('[VehicleCoordinates]+D0', 1125.78369388171) --Y1
writeDouble('[VehicleCoordinates]+900', 1125.78369388171) -- Y2
writeDouble('[VehicleCoordinates]+D8', 216.829617049458) -- Z1
writeDouble('[VehicleCoordinates]+908', 216.829617049458) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136226
"Auto-Paver UC Route 41-18"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1791.95520019531) --X1
writeDouble('[VehicleCoordinates]+8F8', -1791.95520019531) --X2
writeDouble('[VehicleCoordinates]+D0', 936.552673339844) --Y1
writeDouble('[VehicleCoordinates]+900', 936.552673339844) -- Y2
writeDouble('[VehicleCoordinates]+D8', 221.702116056625) -- Z1
writeDouble('[VehicleCoordinates]+908', 221.702116056625) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136227
"Auto-Paver UC Route 41-19"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1795.39697265625) --X1
writeDouble('[VehicleCoordinates]+8F8', -1795.39697265625) --X2
writeDouble('[VehicleCoordinates]+D0', 681.913543642499) --Y1
writeDouble('[VehicleCoordinates]+900', 681.913543642499) -- Y2
writeDouble('[VehicleCoordinates]+D8', 239.150047307136) -- Z1
writeDouble('[VehicleCoordinates]+908', 239.150047307136) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136228
"Auto-Paver UC Route 41-20"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1764.2080078125) --X1
writeDouble('[VehicleCoordinates]+8F8', -1764.2080078125) --X2
writeDouble('[VehicleCoordinates]+D0', 316.475875834156) --Y1
writeDouble('[VehicleCoordinates]+900', 316.475875834156) -- Y2
writeDouble('[VehicleCoordinates]+D8', 271.580222930974) -- Z1
writeDouble('[VehicleCoordinates]+908', 271.580222930974) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136229
"Auto-Paver UC Route 41-21"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1575.04772811104) --X1
writeDouble('[VehicleCoordinates]+8F8', -1575.04772811104) --X2
writeDouble('[VehicleCoordinates]+D0', 385.355081324058) --Y1
writeDouble('[VehicleCoordinates]+900', 385.355081324058) -- Y2
writeDouble('[VehicleCoordinates]+D8', 300.851469220826) -- Z1
writeDouble('[VehicleCoordinates]+908', 300.851469220826) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136230
"Auto-Paver UC Route 41-22"
Auto Assembler Script
[enable]
{$lua}
X1 = readDouble('[VehicleCoordinates]+C8')
X2 = readDouble('[VehicleCoordinates]+8F8')
if X1 == X2 then
writeDouble('[VehicleCoordinates]+C8', -1216.54582084075) --X1
writeDouble('[VehicleCoordinates]+8F8', -1216.54582084075) --X2
writeDouble('[VehicleCoordinates]+D0', 281.612884521484) --Y1
writeDouble('[VehicleCoordinates]+900', 281.612884521484) -- Y2
writeDouble('[VehicleCoordinates]+D8', 361.314899770281) -- Z1
writeDouble('[VehicleCoordinates]+908', 361.314899770281) -- Z2
end
function onMemRecPostExecute(memoryrecord, newState, succeeded )
if memoryrecord.Type == vtAutoAssembler and memoryrecord.Script:find("NO_ACTIVATE") and newState and succeeded then
memoryrecord.disableWithoutExecute()
end
end
{$asm}
{NO_ACTIVATE}
[disable]
136231
"Auto-Paver UC Route 41-23"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-1196.4039278344) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-1196.4039278344) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',453.9422526133) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',453.9422526133) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',380.61605905702) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',380.61605905702) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136232
"Auto-Paver UC Route 41-24"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-973.99561203708) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-973.99561203708) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',380.53897507775) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',380.53897507775) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',446.15291450197) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',446.15291450197) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136233
"Auto-Paver UC Route 41-25"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-773.79475086742) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-773.79475086742) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',411.89520930171) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',411.89520930171) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',482.67213861051) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',482.67213861051) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136234
"Auto-Paver UC Route 41-26"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-457.04880447841) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-457.04880447841) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',277.03025944506) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',277.03025944506) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',558.09044397078) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',558.09044397078) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136235
"Auto-Paver UC Route 41-27"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',-268.93919919326) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',-268.93919919326) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',276.46442254176) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',276.46442254176) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',506.95541708206) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',506.95541708206) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136236
"Auto-Paver UC Route 41-28"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',166.40418110235) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',166.40418110235) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',508.34461635946) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',508.34461635946) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',416.38707793523) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',416.38707793523) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136237
"Auto-Paver UC Route 41-29"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',156.24398290283) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',156.24398290283) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',204.61320934051) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',204.61320934051) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',311.0593891684) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',311.0593891684) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136238
"Auto-Paver UC Route 41-30"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',389.48972951954) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',389.48972951954) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',144.80882932268) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',144.80882932268) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',222.92714577752) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',222.92714577752) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136239
"Auto-Paver UC Route 41-31"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',628.96002919014) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',628.96002919014) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',503.9127466354) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',503.9127466354) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',182.667704271) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',182.667704271) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136240
"Auto-Paver UC Route 41-32"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',701.23638720054) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',701.23638720054) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',592.94320217879) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',592.94320217879) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',169.23416057413) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',169.23416057413) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136241
"Auto-Paver UC Route 41-33"
Auto Assembler Script
{$lua}
[ENABLE]
writeDouble('[VehicleCoordinates]+C8',766.60884095638) -- X Coord1
writeDouble('[VehicleCoordinates]+8F8',766.60884095638) -- X Coord2
writeDouble('[VehicleCoordinates]+D0',518.19213097949) -- Y Coord1
writeDouble('[VehicleCoordinates]+900',518.19213097949) -- Y Coord2
writeDouble('[VehicleCoordinates]+D8',156.3113822902) -- Z Coord1
writeDouble('[VehicleCoordinates]+908',156.3113822902) -- Z Coord2
if not syntaxcheck then
synchronize(function()
local t = createTimer()
t.Interval,t.OnTimer = 500,function(tm)
tm.Destroy()
memrec.Active = false
end
end)
end
[DISABLE]
136308
"Disable Save Data Check"
Auto Assembler Script
{ Game : $process
Version:
Date : 2022-03-17
Author : Crashin, credits to giofrida
bypass the profile check, allow you to use other peoples saves
https://www.pcgamingwiki.com/wiki/Death_Stranding#Corrupted_save_data
}
[ENABLE]
aobscanmodule(DisableSaveDataCheck,$process,75 05 41 C6 46 3A 11 48 8D 8D)
DisableSaveDataCheck:
db EB
registersymbol(DisableSaveDataCheck)
[DISABLE]
DisableSaveDataCheck:
db 75
unregistersymbol(DisableSaveDataCheck)
136309
"In-Progress"
1
136316
"//Not Accurate Best Total Score - Complete Combat Training Orders #1 - [Maser Gun] Destroy All Targets To Populate"
Auto Assembler Script
{ Game : $process
Version:
Date : 2024-09-05
Author : pc
This script does blah blah blah
}
[ENABLE]
aobscanmodule(BestTotalScoreAOB,$process,3B 41 08 0F 8E 50 FF FF FF) // should be unique
alloc(newmem,$1000,BestTotalScoreAOB)
alloc(BestTotalScore, 8)
registersymbol(BestTotalScore)
label(code)
label(return)
newmem:
mov [BestTotalScore],rcx
code:
cmp eax,[rcx+08]
jng $process+2DC445B
jmp return
BestTotalScoreAOB:
jmp newmem
nop 4
return:
registersymbol(BestTotalScoreAOB)
[DISABLE]
BestTotalScoreAOB:
db 3B 41 08 0F 8E 50 FF FF FF
unregistersymbol(BestTotalScoreAOB)
unregistersymbol(BestTotalScore)
dealloc(BestTotalScore)
dealloc(newmem)
{
// ORIGINAL CODE - INJECTION POINT: $process+2DC4502
$process+2DC44E4: 41 5D - pop r13
$process+2DC44E6: 41 5C - pop r12
$process+2DC44E8: 5F - pop rdi
$process+2DC44E9: C3 - ret
$process+2DC44EA: 48 63 C1 - movsxd rax,ecx
$process+2DC44ED: 48 8D 0C 40 - lea rcx,[rax+rax*2]
$process+2DC44F1: 48 C1 E1 04 - shl rcx,04
$process+2DC44F5: 49 03 CA - add rcx,r10
$process+2DC44F8: 0F 84 3E FF FF FF - je $process+2DC443C
$process+2DC44FE: 8B 44 24 58 - mov eax,[rsp+58]
// ---------- INJECTING HERE ----------
$process+2DC4502: 3B 41 08 - cmp eax,[rcx+08]
// ---------- DONE INJECTING ----------
$process+2DC4505: 0F 8E 50 FF FF FF - jng $process+2DC445B
$process+2DC450B: C5 FC 10 44 24 50 - vmovups ymm0,[rsp+50]
$process+2DC4511: C5 FC 11 01 - vmovups [rcx],ymm0
$process+2DC4515: C5 F8 11 71 20 - vmovups [rcx+20],xmm6
$process+2DC451A: 41 C6 45 00 01 - mov byte ptr [r13+00],01
$process+2DC451F: 2B 41 08 - sub eax,[rcx+08]
$process+2DC4522: 48 8B 8C 24 D0 00 00 00 - mov rcx,[rsp+000000D0]
$process+2DC452A: 89 01 - mov [rcx],eax
$process+2DC452C: E9 24 FF FF FF - jmp $process+2DC4455
$process+2DC4531: 48 63 C3 - movsxd rax,ebx
}
136317
"Combat Training Orders #1 - [Maser Gun] Destroy All Targets - Best Total Score"
0
4 Bytes
BestTotalScore
8
136318
"Combat Training Orders #2 - [Maser Gun] Eliminate all MULEs"
0
4 Bytes
BestTotalScore
38
136400
"Total Likes Received on Menu"
Auto Assembler Script
{ Game : ds.exe
Version:
Date : 2024-09-08
Author : pc
This script does blah blah blah
}
[ENABLE]
aobscanmodule(TotalLikesReceivedAOB,ds.exe,2B 8B 38 01 00 00) // should be unique
alloc(newmem,$1000,TotalLikesReceivedAOB)
alloc(TotalLikesReceived, 8)
registersymbol(TotalLikesReceived)
label(code)
label(return)
newmem:
mov [TotalLikesReceived],rbx
code:
sub ecx,[rbx+00000138]
jmp return
TotalLikesReceivedAOB:
jmp newmem
nop
return:
registersymbol(TotalLikesReceivedAOB)
[DISABLE]
TotalLikesReceivedAOB:
db 2B 8B 38 01 00 00
unregistersymbol(*)
dealloc(*)
{
// ORIGINAL CODE - INJECTION POINT: ds.exe+27325A8
ds.exe+273256F: 40 88 B8 B8 FC 00 00 - mov [rax+0000FCB8],dil
ds.exe+2732576: 48 8B 93 B8 00 00 00 - mov rdx,[rbx+000000B8]
ds.exe+273257D: 48 81 C2 1C 06 00 00 - add rdx,0000061C
ds.exe+2732584: E8 87 28 FE FF - call ds.exe+2714E10
ds.exe+2732589: C6 83 B8 03 00 00 0B - mov byte ptr [rbx+000003B8],0B
ds.exe+2732590: 48 8B 0D 19 5E 4C 05 - mov rcx,[ds.exe+7BF83B0]
ds.exe+2732597: B2 02 - mov dl,02
ds.exe+2732599: E8 12 8E 6D 00 - call ds.exe+2E0B3B0
ds.exe+273259E: 48 8B BC 24 A0 00 00 00 - mov rdi,[rsp+000000A0]
ds.exe+27325A6: 8B C8 - mov ecx,eax
// ---------- INJECTING HERE ----------
ds.exe+27325A8: 2B 8B 38 01 00 00 - sub ecx,[rbx+00000138]
// ---------- DONE INJECTING ----------
ds.exe+27325AE: F6 83 C0 03 00 00 08 - test byte ptr [rbx+000003C0],08
ds.exe+27325B5: 89 8B 3C 01 00 00 - mov [rbx+0000013C],ecx
ds.exe+27325BB: 89 83 38 01 00 00 - mov [rbx+00000138],eax
ds.exe+27325C1: 74 06 - je ds.exe+27325C9
ds.exe+27325C3: 89 AB 3C 01 00 00 - mov [rbx+0000013C],ebp
ds.exe+27325C9: C5 FA 10 0D 9B 9B 46 01 - vmovss xmm1,[ds.exe+3B9C16C]
ds.exe+27325D1: 40 38 AB 84 00 00 00 - cmp [rbx+00000084],bpl
ds.exe+27325D8: 74 1A - je ds.exe+27325F4
ds.exe+27325DA: C5 B2 58 43 7C - vaddss xmm0,xmm9,[rbx+7C]
ds.exe+27325DF: C5 F8 2F C1 - vcomiss xmm0,xmm1
}
136451
"[0]"
0
4 Bytes
TotalLikesReceived
0
136401
"Total Likes Received on Menu"
0
4 Bytes
TotalLikesReceived
138
136474
"?"
0
Float
TotalLikesReceived
34C
136475
"?"
0
Float
TotalLikesReceived
32C
136476
"?"
0
Float
TotalLikesReceived
338
136477
"?"
0
Float
TotalLikesReceived
3A0
Vehicle Durability:
0=Destroyed
7500=Trike Max
15000=Truck Max
6500=MULEs Truck
-----------------------------
Vehicle Physical Condition:
0-1,
0=Full Rust
1=No Rust
-----------------------------
Vehicle Battery:
0=Dead Battery
4500=Truck Max
5850=Truck: Longe Range (Lvl 1)
7200=Truck: Longe Range (Lvl 2)
9000=Truck: Longe Range (Lvl 3)
3000=Reverse Trike Max
4500=Reverse Trike: "Ride" Type
6000="Reverse Trike: Long Range Max
2250=MULEs Truck
-----------------------------
Bridge Boots Durability:
0=Broken Boots
1000=Bridge Boots (Lvl 1)
1300=Bridge Boots (Lvl 2)
1700=Bridge Boots (Lvl 3)
600=MULE Boots
600=Chiral Boots
800=Terrorists Boots
800=Porter Boots
-----------------------------
BB Stress Bar
0=No Stress
1000=Full Stress
-----------------------------
Backpack Physical Condition
0=Full Rust
5000=No Rust
-----------------------------
Optional Backpack Cover Condition
0=Destroyed/Have To Go Create Another
3000=Max for Lvl 1
4500=Max for Lvl 2
-----------------------------
*****All Normal Difficulty if it changes unless otherwise noted*****
Episode 4 - Order 39 - Unger Health (Very Hard)
14000=Max
Episode 4 - Order 39 - Unger Minions
2000=Max
Episode 7 - Order 39 - Unger Health (Found on Very Hard, may be same)
21000=Max
Episode 7 - Order 39 - Unger Minions (Found on Very Hard, may be same)
2600=Max
Episode 9 - Order 64 - BT Boss Health
200000=Max
Episode 9 - Order 65 - Higgs Health [Phase 1 Part 1 - Shooting]
12000=Max
Episode 9 - Order 65 - Higgs Health [Phase 1 Part 2 - Knife Fight]
13000=Max
Episode 9 - Order 65 - Higgs Health [Phase 2 - Punch Out]
5000=Max
Episode 9 - Order 65 - Player Health [Phase 2 - Punch Out]
1000=Max
Episode 9 - Order 65 - Player Stamina [Phase 2 - Punch Out]
1=Max
Episode 11 - Order 67 - Unger Health (Found on Very Hard, may be same)
25000=Max
Episode 12 - Order 68 - BT Health (Found on Very Hard, may be same)
100=Max
All Other BT's
100=Max
MULEs
1000=Max
Terrorists
1500=Max
-----------------------------
Blood Bags:
500=Blood Bag Max
1000=High-capacity Blood Bags
-----------------------------
0=100% Container Damage
900=Max Thermal Container Damage
3000=Max Thermal Damage
-----------------------------
Machine Gun Timer:
0=Attack
~100-101=Overheated
-----------------------------
100=Max Roads
360000=(lvl 1) Structures, Ladder, Anchor (Lvl 1) etc.
540000=(Lvl 2) Structures, Anchor (Lvl 2) etc.
900000=(Lvl 2) Structures
"$process"+2930379
No Recoil