Bruno Kestemont Lv 1
only dessert
Profile
- Name
- JET 3.6
- ID
- 102349
- Shared with
- Public
- Parent
- JET 3.5
- Children
- Created on
- June 14, 2017 at 18:20 PM UTC
- Updated on
- June 14, 2017 at 18:20 PM UTC
- Description
Multiple LWS and AT with puzzle exploration, by Bruno Kestemont
Best for
Code
--JET 3.5, 2/10/2013 multilingual and more efficient
--Based on Total lws 1.0.4., WalkeR, LuckyLWS , Precise LWS and now also Acid Tweeker and others from multiwalk
--Best for joining evolver competition, or for very end of game to get the latest points
--do total LWS with different options then Lucky then Precise untill smallest gains.
--Most gains are optained in the beginning, so stop when you have enough, unless you are on the final sprint
--Bruno Kestemont 10 Jun 2013. Thanks to Jean-Bob
--added idealize function for PreciseLWS and Lucky LWS 19/7/2013. Not sure it's usefull (removed 25/8/13)
--new Stanley version with pentamers
--GRRR Had to change other by density
--to do: Lucky LWS is not very efficient on end puzzles
--2/10/13 raccourcit menu principal si deja fait. Imprime skipthis au bon moment
--16/10/13 a verifier: print module pas catholique
--3.2.2 nc adapted
--3.3 added Worm and adapted wiggle sequence
--3.4 intelligent filter management 01/09/2014
--3.4.1 Added notes and replaced QuickShake
--3.4.2 added maximo in at: should speed up
--3.5.0 added howmany and other SD-multiwalk functions
--3.5.1 fixed iFilterSettings
--3.5.2 fixed score(true) & added filterB in target 30/4/2015
--3.5.3 fixed test filter effect
--3.6 with dialog for only dessert, now skipping 2 twice a failing recipe
--Documentation en FR pour edition a la fin
---------------------------------------------------------------------------------------
--Start Generic JET parameters and functions
recipeName="JET 3.6"
FirstJET=true
historic=recipeName
global_ci=1
JETgain=0 --gain depuis le debut
gainRecipe=0 --gain de chaque recette
firstGain=0 --gain premiere recette
interuptor=false
comptetour=1
nextskip="" -- will be asigned a function name with no gain
oldskip="" -- in order to be able to retain 2 functions to skip
skipthis=false
lwsTable={} -- pour WalkeR
sphere_worst=false -- for AT, include worst segments in sphere or not
sphere_worst_value=0 -- for AT Intervient dans SelectSphere() pour decider a partir de quel score selectionner le segment voisi
save.Quicksave(9) --pour initialiser l'antepenultieme solution
save.Quicksave(10) --pour initialiser la version evoluable
save.Quicksave(11) --pour initialiser la version actuelle
saveNote1=structure.GetNote(1)
note1libre=true
OriginalFilterSetting = behavior.GetSlowFiltersDisabled() -- new BK 8/4/2013
bigLw=25 -- long wiggle pour New Chapter 26/02/2014
--Note: other calculated parameters are to be found in Stanley function section or elsewere bellow.
--end generic JET parameters and functions
-- Stanley V1.2, by B. Kestemont 19/06/2013
-- To find puzzle properties and targets
-- properties based on Tvdl 14-12-2012, autonomous enhanced version (BK 25/1/2012)
-- Targets by B. Kestemont
----------------------------------------------------------
--start generic Stanley variables section-------------------------
segCnt=structure.GetCount()
--segCnt=segCnt-1 -- for lingard puzzles only! sera initialise par seglock
flagligand=false
segCnt2=segCnt -- cas de ligands
while structure.GetSecondaryStructure(segCnt2)=="M" do segCnt2=segCnt2-1 flagligand=true end
segStart=1 --start from (Default option for JET)
segEnd=segCnt2 --end seg: nil=end of protein (Default option for JET) -- duplicat a verifier
badpuzzle={'713'} -- list of not implemented puzzles - to be edited on each bug
NOTIMPLEMENTED=false
WORKON={{1,segCnt2}}
normal= (current.GetExplorationMultiplier() == 0)
Cyslist={}
savebridges=false --default no bridgechecking
nrofbridges=0
HASMUTABLE=false
HASOTHER=false
OTHERWEIGHT=0
PROBABLESYM=false
PROBABLEFILTER=false
SEPSIS=false
ELECTRON=false
sym= 1 --Options: 1 normal; 2 dimer; 3 trimer; 4 tetramer (dimer of dimer) etc.
FREEDESIGN=false
timeLeft=os.difftime(puzzle.GetExpirationTime(),os.time())/86400 -- en jours
startTime=os.time() -- en secondes?
pprankrel=0.015*timeLeft/8 --pts per rank relative to score. Actuellement calibr sur 670 a 8 jours de la fin
groupscore=10*(800-scoreboard.GetGroupScore())
grouprank=scoreboard.GetGroupRank()
absbestscore=10*(800-absolutebest.GetScore()) -- changed BK 16/10/2013
flaglocked=false
lang="en"
uo={energy = false} -- a duplicate on Ebola but it's needed here before score computing
StartMultiplier=current.GetExplorationMultiplier() -- New BK 16/10/2013 for exploration puzzles
multiplier=StartMultiplier
if normal then multiplier=1 end -- case of normal puzzle
--end generic Stanley variables section--------------------------
--Start merged Stanley and recipe functions
function checkbadpuzzle()
if NOTIMPLEMENTED then
print("WARNING ! Puzzle not implemented")
end
end
function setlanguage()-- New BK 10/4/13
local player=user.GetPlayerName()
local group=user.GetGroupName()
if group=="L'Alliance Francophone" or player=="marie_s" or player=="bruno.kestemont" or player=="roukess" then
lang="fr"
else
lang="en"
end
return lang
end
function multilingual(lang)-- New BK 10/4/13, 25/8/13 WARNING: TO BE EDITTED FOR EACH RECIPE
if lang=="fr" then
-- translation table. do NOT replace %-letter combos
i18={
intro={
title="Stanley explorer 1.2 par BK",
exploration="Exploration du puzzle:"
},
ask={
ok="OK",
cancel="Annuler",
logCancel= "Action annule",
options={OnlyDessert= "Rien que le dessert svp (fin de jeu)"
},
},
stanley={
unlocked="-Libre: ",
bridges=" ponts;",
currenttarget="Objectif actuel: ",
cysteins=" cystides;",
distance2target="Distance l'objectif = ",
endstanley="Fin du module d'exploration Stanley",
to=" to ",
thereare="-Il y a ",
nolock="-pas de lock; ",
ligands="-ligands: ",
nobridge="-pas de pont;",
nobridgepossible="-pas de possibilit de pont;",
noligand="-pas de ligand;",
sepsis="Sepsis",
electron="Electron Density",
freedesign="-probablement free design;",
lookingtarget="Recherche d'un objectif",
maybe=" -peut-tre ",
nofreedesign="-pas free design;",
nomutable="-pas mutable;",
otherscore="-autres scores d'un poids suppplmentaire de ",
explorationpuzzle="Puzzle d'exploration",
nootherscore="-pas d'autre score;",
mutable="-mutable;",
mutables=" mutables;",
setoftargets="Jeu de cibles: ",
sym="-symtrique",
symdescr="-la destription parle de symtrique ...",
contacts="-contacts",
topscore="Top score estim: ",
nosym=" ... pas symtrique",
dimer=" ... dimre",
trimer=" ... trimre",
tetramer=" ... tetramre ou dimre de dimre",
pentamer=" ... pentamre"
},
recipe={
is3="tat du script restaur.",
m3a="Traitement des paramtres initiaux termin.",
m3b="Parcours systmatique de la protine.",
lw1="Rtablissement du meilleur score.",
lw2="Rtablissement de la structure secondaire.",
lw3="Rtablissement des bandes.",
lw4="Sauvegarde de l'tat du script dans note 1",
de1="Arrt utilisateur.",
de2="Erreur inattendue dtecte.",
de3="Ligne d'erreur : %i.",
de4="Message d'erreur : %s."
},
jet={
intro1="Join Evolver Team ("..recipeName..")",
intro2="Score de DEPART= ",
intro3="1 nuit de travail PC. Bonne nuit ",
signature="Signature dans note du segment 1",
running1="",
running2=" en cours ",
skipping="Saute ",
runningdessert="PETIT DESSERT n ",
maindishes="PLAT PRINCIPAL",
nogain="... ne gagna plus rien en ",
gain1="... gagna ",
gain2=" points en ",
tweak1="1) Tweak, remuer chaines latrales",
tweak2="2) Tweak around, remuer chaines latrales",
tweak3="3) Manipulateur brutal des chaines latrales",
tweakgain1="Gain Tweak: ",
tweakgain2="Gain Tweak around: ",
tweakgain3="Gain manipulateur: ",
tweakgain3nil=". Ignor si <0",
score="Score actuel ",
gainT=". >>>>Gain JET= ",
gainin="<<<< en ",
gaining="(gain en cours: ",
timeleft="Temps restant: ",
hours=" heures.",
maygain="Peut encore gagner ",
cleaning="Nettoyage",
restorestructure="Rtablissement de la structure secondaire",
savingbest="Enregistrement du meilleur rsultat",
undosave="Enregistrement de solution voluable dans Undo ou Slot 9",
alreadydone=" a dja te utilise.",
middlegame="Interruption de JET pour milieu de partie",
stopnow="Inutile d'insister avec JET maintenant",
suggestEbola="Je vous conseille de lancer Ebola",
interrupt="Interruption de JET, perte anormale",
signalerror="Merci de signaler ce bug a l'auteur"
}
}
else
i18={
intro={
title="Stanley explorer 1.2 by BK",
exploration="Puzzle exploration:"
},
ask={
ok="OK",
cancel="Cancel",
logCancel= "Action cancelled",
options={OnlyDessert="Only Dessert please (end game)"
},
},
stanley={
unlocked="-Unlocked: ",
to=" to ",
bridges=" bridges;",
currenttarget="Current target: ",
cysteins=" cysteins;",
distance2target="Distance to target = ",
endstanley="End of Stanley exploration module",
thereare="-There are ",
nolock="-no lock; ",
ligands="-ligands: ",
nobridge="-no bridge;",
nobridgepossible="-no possibility of bridge;",
noligand="-no ligand;",
sepsis="Sepsis",
electron="Electron Density",
freedesign="-probable free design;",
lookingtarget="Looking for a target",
maybe=" -may be ",
nofreedesign="-not free design;",
nomutable="-no mutable;",
mutable="-mutable;",
mutables=" mutables;",
otherscore="-other scores; additional weight of ",
explorationpuzzle="Exploration puzzle",
nootherscore="-no other score;",
setoftargets="Set of targets: ",
sym="-symmetric",
symdescr="-description says symmetric ...",
contacts="-contacts",
topscore="Estimated top score: ",
nosym=" ... not symmetric",
dimer=" ... Dimer",
trimer=" ... Trimer",
tetramer=" ... Tetramer or dimer of dimer",
pentamer=" ... Pentamer"
},
recipe={
is3="Script state loaded.",
m3a="Initial parameters treatment completed.",
m3b="Whole protein walking.",
lw1="Loading Highscore...",
lw2="Loading secondary structure...",
lw3="Loading bands...",
lw4="Saving script state in note 1", -- added BK 21/3/13
de1="User stop.",
de2="unexpected error detected.",
de3="Error line: %i.",
de4="Error : %s."
},
jet={
intro1="Join Evolver Team ("..recipeName..")",
intro2="START Score= ",
intro3="1 night PC work. Good night ",
signature="Signature in segment 1 note",
running1="Running ",
running2="",
skipping="Skipping ",
runningdessert="Now running dessert n ",
maindishes="MAIN DISHES",
nogain="... no additional gain in ",
gain1="... gained another ",
gain2=" points in ",
tweak1="Pass 1: Sidechain tweak",
tweak2="Pass 2: Sidechain tweak around",
tweak3="Last chance: bruteforce sidechain manipulate",
tweakgain1="Tweak gain: ",
tweakgain2="Tweak around gain: ",
tweakgain3="Manipulate gain: ",
tweakgain3nil=". Ignored if <0" ,
score="Current score ",
gainT=". >>>>JET gain= ",
gainin="<<<< in ",
gaining="(gaining: ",
timeleft="Time left: ",
hours=" hours.",
maygain="May gain additional ",
cleaning="Cleaning",
restorestructure="Restoring secundary structure",
savingbest="Saving best result",
undosave="Saving evoluable solution in Undo or Slot 9",
alreadydone=" has already been used.",
middlegame="Interruption of JET for middle game",
stopnow="Do not loze more time with JET now",
suggestEbola="I suggest you run Ebola now",
interrupt="Interruption of JET, abnormal to loose points",
signalerror="Thanks to signal this to the author"
}
}
end
return
end
--end merged Stanley and recipes functions
--Start generic Stanley functions section------------------------
function round(x)--cut all afer 3-rd place
return x-x%0.001
end
function down(x)
return x-x%1
end
function p(fmt, ...) --NEW 17/5/13
if #arg==0 then print(fmt or '')
elseif arg==nil then print(fmt or '')-- added BK 23/3/13
elseif fmt==nil then print('')-- added BK 23/3/13
else print(string.format(fmt, unpack(arg))) end
end
function Score()--return score, exploration too
return uo.energy and current.GetEnergyScore() or current.GetScore()
end
function FilterBonus(pose) -- new BK 30/4/2015 (independent from score functions)
local pose=pose or current
local CurrentFilterSetting = behavior.GetFiltersDisabled()
behavior.SetSlowFiltersDisabled(false)
local TvdLscore=pose.GetEnergyScore()
behavior.SetSlowFiltersDisabled(true)
local TvdLscore2=pose.GetEnergyScore()
behavior.SetFiltersDisabled(CurrentFilterSetting)
local TvdLbonus=TvdLscore-TvdLscore2
return TvdLbonus
end
startingscore= Score() -- for recipes
maxScore= Score() -- for recipes
evolbase=down(startingscore)--initialise decimales pour cherchevol() in jet
filterB=FilterBonus() -- new
if filterB<0 then filterB=0 end
C8000=8000+filterB
--[[GetScore and GetGroupScore return the rosetta energy. To convert this to your score use this:
10 * (800 - Rosetta Energy) = Foldit Score
The rosetta energy is a negative number and lower is better]]--
--Trouver le score de reference en fonction des resultats de l'equipe
function TopScore() -- by B.Kestemont 7/2/2013, 16/10/2013
local TopScorevalue=C8000
if groupscore==nil then
if absbestscore==nil then TopScore=Score()+1000 -- BK 16/10/2013
else
if scoreboard.GetRank()<6 then
TopScorevalue=(absbestscore-C8000)*(1+0.039*scoreboard.GetRank())+C8000
else
TopScorevalue=(absbestscore-C8000)*(1+(0.010*(scoreboard.GetRank()-5)+0.039*5))+C8000
end
end
else
if grouprank<6 then
TopScorevalue=(groupscore-C8000)*(1+pprankrel*grouprank)+C8000
else
TopScorevalue=(groupscore-C8000)*(1+0.0038*(grouprank-5)+pprankrel*5)+C8000
end
end
if TopScorevalue<C8000+15*segCnt then TopScorevalue=C8000+17.94*segCnt end -- le minimum observe en fin de compet
return TopScorevalue
end
--end generic Stanley functions section------------------------
--Start generic JET function section
function note1free()
if #saveNote1>0 and saveNote1:find("Ebola") then
historic="JET 3.0 apres Ebola"
elseif #saveNote1>0 then
note1libre=false
end
end
function AllLoop()
local ok=false
-- First save structure !
for i=1, segCnt do
local ss=structure.GetSecondaryStructure(i)
if ss~="L" then
save.SaveSecondaryStructure()
ok=true
break
end
end
if ok then
selection.SelectAll()
structure.SetSecondaryStructureSelected("L")
end
end
function lw(minppi) -- for Total LWS, Precise LWS and Lucky LWS (includes filter optimization)
local gain=true
while gain do
local ss=Score()
WiggleAT(2,"lw")
--WiggleSimple(20,"lws")
--structure.LocalWiggleSelected(20)-- BK 01/02/2014 for NC
local g=Score()-ss
if g<minppi then gain=false end
if g<0 then recentbest.Restore() end
end
selection.DeselectAll() -- new to JET
freeze.UnfreezeAll() -- new to JET
end
function lwWorm(minppi) --translated to Lua2 26/02/2014 (Here: no filter management !)
local minppi=minppi or 0
local s=Score()
--do_local_wiggle(1)
structure.LocalWiggleSelected(1)
if Score()-s>0+minppi then
--do_local_wiggle(bigLw)
structure.LocalWiggleSelected(bigLw)
end
recentbest.Restore()
end
function wiggleBudies(s, minppi, buddies) -- for PreciseLWS and Lucky LWS
--p("Wigglin segment "..s)
selection.DeselectAll()
freeze.UnfreezeAll()
local sgs=Score()
if s+1<=segCnt then selection.Select(s+1)end
if s-1>=1 then selection.Select(s-1)end
freeze.FreezeSelected(true, true) -- geler debut ou fin de proteine
selection.DeselectAll()
selection.Select(s)
lw(minppi) -- only s
if buddies > 0 then --select buddies
for b=1, buddies do
selection.DeselectAll()
if s+b+1<=segCnt then selection.Select(s+b+1)end
if s-1>=1 then selection.Select(s-1)end
freeze.FreezeSelected(true, true)
selection.DeselectAll()
if s+b>segCnt then selection.SelectRange(s,segCnt)
else selection.SelectRange(s,s+b)
end
lw(minppi) -- on s to s+variable to end
if s+1<=segCnt then selection.Select(s+1)end
if s-b-1>=1 then selection.Select(s-b-1)end
freeze.FreezeSelected(true, true)
selection.DeselectAll()
if s-b<1 then selection.SelectRange(1,s)
else selection.SelectRange(s-b,s)
end
lw(minppi) -- on s to s-variable to begin
if s+b+1<=segCnt then selection.Select(s+b+1)end
if s-b-1>=1 then selection.Select(s-b-1)end
freeze.FreezeSelected(true, true)
selection.DeselectAll()
if s+b>segCnt then selection.SelectRange(s,segCnt)
else selection.SelectRange(s,s+b)end
if s-b<1 then selection.SelectRange(1,s)
else selection.SelectRange(s-b,s)end
lw(minppi) -- on s-variable to s+variable
end
end
sge=Score()
--p("Segment gain: "..sge-sgs)
end
--end generic JET function section
--------------------------------------------------------------
-- Module Stanley 1.2, by B. Kestemont 19/06/2013, 25/8/2013
-- To find puzzle properties and targets
-- properties based on Tvdl 14-12-2012
-- Autonomous enhanced version (BK 25/1/2013)
-- Targets by B. Kestemont
----------------------------------------------------------
--generic variables section merged to top -------------------------
--generic functions section merged to top------------------------
------------------------------------------------------
-- Segment set and list module
-- Notice that most functions assume that the sets are well formed
-- (=ordered and no overlaps)
-- 02-05-2012 TvdL Free to use for non commercial purposes
function SegmentListToSet(list) -- retirer doublons
local result={}
local f=0
local l=-1
table.sort(list)
for i=1,#list do
if list[i] ~= l+1 and list[i] ~= l then
-- note: duplicates are removed
if l>0 then result[#result+1]={f,l} end
f=list[i]
end
l=list[i]
end
if l>0 then result[#result+1]={f,l} end
--print("list to set")
--SegmentPrintSet(result) -- desactivated this print BK 17/6/13
return result
end
function SegmentSetToList(set) -- faire une liste a partir d'une zone
local result={}
for i=1,#set do
--print(set[i][1],set[i][2])
for k=set[i][1],set[i][2] do
result[#result+1]=k
end
end
return result
end
function SegmentCleanSet(set)
-- Makes it well formed
return SegmentListToSet(SegmentSetToList(set))
end
function SegmentInvertSet(set,maxseg)
-- Gives back all segments not in the set
-- maxseg is added for ligand
local result={}
if maxseg==nil then maxseg=structure.GetCount() end
if #set==0 then return {{1,maxseg}} end
if set[1][1] ~= 1 then result[1]={1,set[1][1]-1} end
for i=2,#set do
result[#result+1]={set[i-1][2]+1,set[i][1]-1}
end
if set[#set][2] ~= maxseg then result[#result+1]={set[#set][2]+1,maxseg} end
return result
end
function SegmentInList(s,list) -- verifier si segment est dans la liste
table.sort(list)
for i=1,#list do
if list[i]==s then return true
elseif list[i]>s then return false
end
end
return false
end
function SegmentInSet(set,s) --verifie si segment est dans la zone
for i=1,#set do
if s>=set[i][1] and s<=set[i][2] then return true
elseif s<set[i][1] then return false
end
end
return false
end
function SegmentJoinList(list1,list2) -- fusionner 2 listes de segments
local result=list1
if result == nil then return list2 end
for i=1,#list2 do result[#result+1]=list2[i] end
table.sort(result)
return result
end
function SegmentJoinSet(set1,set2) --fusionner (ajouter) 2 zones
return SegmentListToSet(SegmentJoinList(SegmentSetToList(set1),SegmentSetToList(set2)))
end
function SegmentCommList(list1,list2) -- chercher intersection de 2 listes
local result={}
table.sort(list1)
table.sort(list2)
if #list2==0 then return result end
local j=1
for i=1,#list1 do
while list2[j]<list1[i] do
j=j+1
if j>#list2 then return result end
end
if list1[i]==list2[j] then result[#result+1]=list1[i] end
end
return result
end
function SegmentCommSet(set1,set2) -- intersection de 2 zones
return SegmentListToSet(SegmentCommList(SegmentSetToList(set1),SegmentSetToList(set2)))
end
function SegmentSetMinus(set1,set2)
return SegmentCommSet(set1,SegmentInvertSet(set2))
end
function SegmentPrintSet(set)
print(SegmentSetToString(set))
end
function SegmentSetToString(set) -- pour pouvoir imprimer
local line = ""
for i=1,#set do
if i~=1 then line=line..", " end
line=line..set[i][1].."-"..set[i][2]
end
return line
end
function SegmentSetInSet(set,sub)
if sub==nil then return true end
-- Checks if sub is a proper subset of set
for i=1,#sub do
if not SegmentRangeInSet(set,sub[i]) then return false end
end
return true
end
function SegmentRangeInSet(set,range)--verifier si zone est dans suite
if range==nil or #range==0 then return true end
local b=range[1]
local e=range[2]
for i=1,#set do
if b>=set[i][1] and b<=set[i][2] then
return (e<=set[i][2])
elseif e<=set[i][1] then return false end
end
return false
end
function SegmentSetToBool(set) -- vrai ou faux pour chaque segment utilisable ou non
local result={}
for i=1,structure.GetCount() do
result[i]=SegmentInSet(set,i)
end
return result
end
--- End of Segment Set module
-- Module Find Segment Types
function FindMutablesList()
local result={}
for i=1,segCnt2 do if structure.IsMutable(i) then result[#result+1]=i end end
return result
end
function FindMutables()
return SegmentListToSet(FindMutablesList())
end
function FindFrozenList()
local result={}
for i=1,segCnt2 do if freeze.IsFrozen(i) then result[#result+1]=i end end
return result
end
function FindFrozen()
return SegmentListToSet(FindFrozenList())
end
function FindLockedList()
local result={}
for i=1,segCnt2 do if structure.IsLocked(i) then result[#result+1]=i end end
return result
end
function FindLocked()
return SegmentListToSet(FindLockedList())
end
function FindSelectedList()
local result={}
for i=1,segCnt do if selection.IsSelected(i) then result[#result+1]=i end end
return result
end
function FindSelected()
return SegmentListToSet(FindSelectedList())
end
function FindAAtypeList(aa)
local result={}
for i=1,segCnt2 do
if structure.GetSecondaryStructure(i)== aa then result[#result+1]=i end
end
return result
end
function FindAAtype(aa)
return SegmentListToSet(FindAAtypeList(aa))
end
function FindAminotype(at) --NOTE: only this one gives a list not a set
local result={}
for i=1,segCnt2 do
if structure.GetAminoAcid(i) == at then result[#result+1]=i end
end
return result
end
-- end Module Find Segment Types
-- Module to compute subscores
-- TvdL, 14-12-2012
function GetSubscore(types,seg1,seg2,pose)
local result=0
if type(types) == "table" then
for i=1,#types do result=result+GetSubscore(types[i],seg1,seg2,pose) end
else
if types==nil and seg1==nil and seg2==nil then return Score(pose) end
if seg1==nil then seg1=1 end
if seg2==nil then seg2=segCnt end --includes ligands!
if seg1>seg2 then seg1,seg2=seg2,seg1 end
if pose==nil then pose=current end
if types==nil then
for i=seg1,seg2 do result=result+pose.GetSegmentEnergyScore(i) end
else
for i=seg1,seg2 do result=result+pose.GetSegmentEnergySubscore(i,types) end
end --rappel: current.GetSegmentEnergySubscore(integer segmentIndex, string scorePart)
end
return result
end
-- End module to compute subscores
-------------------------------------------------------
-- Start of module for bridgechecking-------------------
function setCyslist()
Cyslist=FindAminotype("c")
nrofbridges=CountBridges()
end
function IsBridge(i)
return ''..current.GetSegmentEnergySubscore(i,'disulfides') ~= '-0'
end
function CountBridges()
local count = 0
for i = 1,#Cyslist do
if IsBridge(Cyslist[i]) then count = count + 1 end
end
return count
end
function BridgesBroken()
return savebridges == true and CountBridges() < nrofbridges
end
function Bridgesave()
if savebridges then PushPosition() end
end
function Bridgerestore()
if savebridges then
if BridgesBroken() then PopPosition() else ClrTopPosition() end
end
end
-- End module bridgechecking
---Start Module to find segment properties------------
function FindAminotype(at) --NOTE: only this one gives a list not a set
local result={}
for i=1,segCnt2 do
if structure.GetAminoAcid(i) == at then result[#result+1]=i end
end
return result
end
--Detect ligands (from Jean-Bob)
--[[
function DetectLigand()
local lastSeg=segEnd
while structure.GetSecondaryStructure(lastSeg)=="M" do
flagligand=true -- servira plus tard pour travailler sur ligands
lastSeg=lastSeg-1
end
indexligand={lastSeg,segEnd} --donne toujours 2??
if flagligand then p(i18.stanley.ligands..#indexligand) else
--p("-pas de ligand; ")
p(i18.stanley.noligand)
end
segEnd=lastSeg -- pour eviter bugs out of bound NEW 18/5/2013
end
]]--
function SetPuzzleProperties()
--p("Exploration du puzzle")
p(i18.intro.exploration)
--check if the puzzle has ligands and computes LastSeg
--DetectLigand()
--DetectLock()
-- Find out if the puzzle has mutables
local MutList=FindMutablesList()
HASMUTABLE= (#MutList>0)
if HASMUTABLE then
--p("-il y a "..#MutList.." mutables;")
p(i18.stanley.thereare..#MutList..i18.stanley.mutables)
else
--p("-pas de mutable;")
--p(i18.stanley.nomutable)
end
FREEDESIGN= (segCnt2/2 < #MutList)
if FREEDESIGN then
--p("-probablement free design;")
p(i18.stanley.freedesign)
else
--p("-pas free design")
--p(i18.stanley.nofreedesign)
end
-- Find out if the puzzle has possible bridges
setCyslist()
--p("- "..#Cyslist.." cystides;")
p(i18.stanley.thereare..#Cyslist..i18.stanley.cysteins)
if #Cyslist > 1 then
if nrofbridges > 0 then
--p(" -il y a "..nrofbridges.." ponts;")
p(" -there are "..nrofbridges.." bridges;")
p(i18.stanley.thereare..nrofbridges..i18.stanley.bridges)
savebridges=true
else
--p(" -pas de pont;")
p(i18.stanley.nobridge)
end
else
--p(" -pas de possibilite de pont;")
p(i18.stanley.nobridgepossible)
end
-- Find out is the puzzle has other scores and their weight if any (e.g. ED)
local othertot=GetSubscore("density")
local segtot=GetSubscore(nil,1,segCnt) -- attention sera nil si lock
HASOTHER= math.abs(othertot) > 0.0001
if normal and HASOTHER then
OTHERWEIGHT=(Score()-segtot-8000)/othertot -- c'est pas l'inverse?
--p("-autres scores; poids supplementaire de "..round(OTHERWEIGHT))
p(i18.stanley.otherscore..round(OTHERWEIGHT))
else
--p("-pas d'autre score;")
p(i18.stanley.nootherscore)
end
-- Check if the puzzle is a probable symmetry one
if normal and not HASOTHER then
PROBABLESYM=math.abs(Score()-segtot-C8000) > 2 -- c'est pas plutot diviser?
end
if not normal then p(i18.stanley.explorationpuzzle) end
end
--recherche du nombre probable de brins en fonction du score(appele par puzzleprop)
function SymetryFinder() -- by Bruno Kestemont 7/2/2013, 25/8/2013
local segMeanScore=(TopScore()/multiplier-C8000)/segCnt -- top score pour eviter les debuts de puzzle
-- taking (our) multiplier as a proxy or 1 if normal
if PROBABLESYM and normal then -- delete normal if sym exploration puzzles appears!
if segMeanScore<33.39 then sym=1
PROBABLESYM=false
elseif segMeanScore<85 then sym=2
elseif segMeanScore<132 then sym=3
elseif segMeanScore<197 then sym=4
else sym=5
end
else sym=1
end
return
end
--Extrait des infos
function puzzleprop() -- by Bruno Kestemont 25/8/2013
local descrTxt=puzzle.GetDescription()
--p(descrTxt)
local puzzletitle=puzzle.GetName()
--p(puzzletitle)
if #puzzletitle>0 then
for i=1,#badpuzzle do
if puzzletitle:find(i) then -- check if not bizarre puzzle
NOTIMPLEMENTED=true
end
end
if (puzzletitle:find("Sym") or puzzletitle:find("Symmetry") or puzzletitle:find("Symmetric")
or puzzletitle:find("Dimer") or puzzletitle:find("Trimer") or puzzletitle:find("Tetramer")
or puzzletitle:find("Pentamer")) then
PROBABLESYM=true
if puzzletitle:find("Dimer") and not puzzletitle:find("Dimer of Dimers") then sym=2
elseif puzzletitle:find("Trimer") or puzzletitle:find("Tetramer") then sym=3
elseif puzzletitle:find("Dimer of Dimers") or puzzletitle:find("Tetramer") then sym=4
elseif puzzletitle:find("Pentamer") then sym=5
else SymetryFinder()
end
end
end
if #descrTxt>0 and (descrTxt:find("Sym") or descrTxt:find("Symmetry") or descrTxt:find("Symmetric")
or descrTxt:find("sym") or descrTxt:find("symmetry") or descrTxt:find("symmetric")) then
PROBABLESYM=true
if (descrTxt:find("Dimer") or descrTxt:find("dimer"))
and not (descrTxt:find("Dimer of Dimers") or descrTxt:find("dimer of dimers")) then sym=2
elseif descrTxt:find("Trimer") or descrTxt:find("trimer") then sym=3
elseif (descrTxt:find("Dimer of Dimers") or descrTxt:find("Tetramer"))
and not (descrTxt:find("dimer of dimers") or descrTxt:find("tetramer"))then sym=4
elseif descrTxt:find("Pentamer") or descrTxt:find("pentamer") then sym=5
else SymetryFinder() -- may be duplicate but it's safe
end
end
--print resulting sym info
if PROBABLESYM then
p(i18.stanley.sym)
if sym==2 then
p(i18.stanley.dimer)
elseif sym==3 then
p(i18.stanley.trimer)
elseif sym==4 then
p(i18.stanley.tetramer)
elseif sym==5 then
p(i18.stanley.pentamer)
elseif sym>5 then
p("Terrible polymer")
end
else p(i18.stanley.nosym)
end
if #descrTxt>0 and (descrTxt:find("filter") or descrTxt:find("filters")) then
PROBABLEFILTER=true
end
if #puzzletitle>0 and puzzletitle:find("Sepsis") then -- new BK 17/6/2013
SEPSIS=true
--p("-Sepsis")
p(i18.stanley.sepsis)
end
if #puzzletitle>0 and puzzletitle:find("Electron Density") then -- for Electron Density
--p("-Electron Density")
ELECTRON=true
p(i18.stanley.electron)
end
if #puzzletitle>0 and puzzletitle:find("Contacts") then -- for Electron Density
--p("-Contacts")
CONTACT=true
p(i18.stanley.contacts)
end
if #descrTxt>0 and (descrTxt:find("Contacts") or descrTxt:find("Contact")) then
--p("-Contacts")
CONTACT=true
p(i18.stanley.contacts)
end
return
end
function fullsubscorelist() -- new BK 23/9/2013
subscorelist=puzzle.GetPuzzleSubscoreNames()
for i=1,#subscorelist do
print (subscorelist[i])
end
end
--fin d'extrait des infos
---End of Module to find segment properties------------
--Start module target settings
function TargetFinder(sym) -- by Bruno Kestemont 16/2/2013 -- Stanley V1.3 version, 30/4/2015
--sym= 1 --Options: 1 normal; 2 dimer; 3 trimer; 4 tetramer (dimer of dimer) etc.
--p("Recherche d'un objectif")
p(i18.stanley.lookingtarget)
local k=1 -- Option: k= 4 if symetric puzzle Dimer, k=6 for trimer, k=8 for tetramer
if sym > 1 then k=2*sym -- reassigning k in function of symetry
TargetMin= multiplier*(13.18*k*segCnt +C8000) -- based on 8000 + min score per segment
TargetLow= multiplier*(17.81*k*segCnt +C8000)
TargetMean= multiplier*(21.14*k*segCnt +C8000)
TargetHigh= multiplier*(24.46*k*segCnt +C8000)
TargetMax= multiplier*(24.65*k*segCnt +C8000)
else
TargetMin= multiplier*(14.03*k*segCnt +C8000)
TargetLow= multiplier*(19.05*k*segCnt +C8000)
TargetMean= multiplier*(22.87*k*segCnt +C8000)
TargetHigh= multiplier*(26.69*k*segCnt +C8000)
TargetMax= multiplier*(33.39*k*segCnt +C8000)
end
--p("Jeu de cibles: "..down(TargetMin)..", ".. down(TargetLow)..", ".. down(TargetMean)..", ".. down(TargetHigh)..", ".. down(TargetMax))
p(i18.stanley.setoftargets..down(TargetMin)..", ".. down(TargetLow)..", ".. down(TargetMean)..", ".. down(TargetHigh)..", ".. down(TargetMax))
return
end
function Dist2target(Target)
--p("Objectif actuel: "..down(Target))
p(i18.stanley.currenttarget..down(Target))
D2target=Target-Score()
relD2target=D2target/Target -- ratio, relative distance to target
--p("Distance a l'objectif = "..down(D2target).." ("..down(relD2target*100).." %)")
p(i18.stanley.distance2target..down(D2target).." ("..down(relD2target*100).." %)")
return
end
function TargetReset()
local topscore=TopScore()
--p("Top score estim: "..down(topscore))
p(i18.stanley.topscore..down(topscore))
if topscore>TargetMax then Dist2target(topscore+10) p("Il y a qque chose qui cloche")
elseif topscore>TargetHigh then Dist2target(TargetMax)
elseif topscore>TargetMean then Dist2target(TargetHigh)
elseif topscore>TargetLow then Dist2target(TargetMean)
elseif topscore>TargetMin then Dist2target(TargetLow)
else Dist2target(TargetMin)
end -- revoit les ambitions en fonction de la situation de l'equipe
end
-- section to compute segmentscore(part)s from tvdl
function getPartscore(ss,se,attr)
local s=0
if attr=='total' then
s=Score()
elseif attr==nil then --is only called from findWorst
for i=ss,se do
s=s+SegmentScores[i]
end
elseif attr=='loctotal' then --total segment scores
s=GetSubscore(nil,ss,se)
else
s=GetSubscore(attr,ss,se)
end
return s
end
-- Do not try to work on frozen or locked parts or ligands
WORKON=SegmentSetMinus(WORKON,FindFrozen())
WORKON=SegmentSetMinus(WORKON,FindLocked())
WORKON=SegmentSetMinus(WORKON,FindAAtype("M"))
WORKONbool={}
function InitWORKONbool()
WORKONbool=SegmentSetToBool(WORKON)
end
function MustWorkon(i,j) -- not used here in stanley
for k=i,j do if not WORKONbool[k] then return false end end
return true
end
SegmentScores={} --Optimalisation for fast worst search
lastSegScores=0
function GetSegmentScores()
if lastSegScores~=Score() then
lastSegScores=Score()
for i=1,segCnt2 do
if WORKONbool[i] then
if #scrPart==0 then
-- if nothing specified by user default is
-- segmentenergy - reference + extra other score
SegmentScores[i]=current.GetSegmentEnergyScore(i)
if not structure.IsMutable(i) then --ignore reference part but NOT for mutables)
SegmentScores[i]=SegmentScores[i]-current.GetSegmentEnergySubscore(i,'reference')
end
if math.abs(OTHERWEIGHT) > 0 then --the other component has extra weight
SegmentScores[i]=SegmentScores[i]+OTHERWEIGHT*current.GetSegmentEnergySubscore(i,'density')
end
else
SegmentScores[i]=GetSubscore(scrPart,i,i)
end
end
end
end
end
-- end section segmentscore(part)s
-- End of module Target settings
function Stanley()
p("------------------")
p(i18.intro.title)
InitWORKONbool() -- new 18/5/13
SetPuzzleProperties()
puzzleprop()
--SymetryFinder() --deja appele par puzzleprop
TargetFinder(sym)
TargetReset()
p(i18.stanley.endstanley)
p("------------------")
end
--END STANLEY MODULE
------------------------------------------------------------------
------------------------------------------------------------------
----------------------------------------------------------------------------------------
-- COOKBOOK -- Adapted recipes to V2 and JET
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
--1. Precise LWS by rav3n_pl
--searches and wiggles worst segments
--some functions shared with Lucky LWS or WalkeR are not repeated
function PreciseLWS(howmany, buddies, minppi) -- wiggle les 5 pires segments
--local howmany = 5 --how many best
--local buddies = 4 -- how many segments aside should be wiggled too
--local minppi = 0.1 --minimum gain per wiggle iterations
local function getPartScore(segments)--using partial scoring -- une ligne de sous-scores
local attr = {'packing','backbone','density','bonding','sidechain','clashing'}--,'hiding','reference','disulfides'}
local score = 0
for i=1,#attr do
score = score + current.GetSegmentEnergySubscore(segments, attr[i])
end
return score
end
local function getworst() --fill score table -- un score partiel par segment
worst={}
for i=1, segCnt do
sc=getPartScore(i) -- somme des scores partiels du segment
worst[i]=sc
end
return worst -- une colonne de segments et leur score
end
local function wiggleworst(howmany, minppi, buddies)
behavior.SetClashImportance(1)
AllLoop()
freeze.UnfreezeAll()
selection.DeselectAll()
recentbest.Save()
sscore=Score()
worst=getworst()
for i=1, howmany do -- Wiggle des howmany pires segments
--p(howmany+1-i.." segments left to do.")
min=worst[1] -- score du segment 1
seg=1
for f=2,segCnt do
if min>worst[f] then
min=worst[f] -- le segment le pire est retenu
seg=f -- n du segment retenu (le pire)
end
end
wiggleBudies(seg, minppi, buddies) -- wiggle le pire segment et voisins
worst[seg]=9999--never again same one -- il est reclasse a la fin
end
local g=Score()-sscore
cherchevol() -- cherche la solution evoluable
--p("Precise LWS gain: ".. g.." pts")
save.LoadSecondaryStructure()
end
wiggleworst(howmany, minppi, buddies)
end
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
--2. WalkeR v1.0
--Original version: WalkeR(segStart, segEnd, minLen, maxLen, minPpi)
--JET adapted version: WalkeR(minLen, maxLen, minPpi)
--[[
WalkeR v1.0
a randomatic LWS script
set from-to -- Disabled for JET
set min-max len of lws
set minimum points per iter
options at end
]]--
function seed()
local s=math.abs(Score())
s=s%0.001
s=1/s
while s<10000000 do s=s*10 end
s=s-s%1
math.randomseed(s)
end
function ShuffeleTable()
-- p("Mixing LWS table...")
local tl=#lwsTable
for i=1,tl do
local n=math.random(tl)
lwsTable[i],lwsTable[n]=lwsTable[n],lwsTable[i]
end
-- p("Mixing done.")
end
--lwsTable={}
function CreateTable(minLen, maxLen)
lwsTable={}
if segEnd==nil then segEnd=segCnt end
for sn=segStart, segEnd do
for l=minLen, maxLen do
if (sn+l-1)<=segEnd then
lwsTable[#lwsTable+1]={sn,l}
end
end
end
end
-- Main WalkeR call ----- Adapted for JET
function WalkeR(minLen, maxLen, minppi)
seed()
CreateTable(minLen, maxLen)
ShuffeleTable()
local sscore=Score()
--p("Starting WalkeR, Score="..round(sscore))
local tl=#lwsTable
for i=1, tl do
local sc=Score()
local s=lwsTable[i][1]
local l=lwsTable[i][2]
selection.DeselectAll()
selection.SelectRange(s,s+l-1)
lw(minppi)
--p("Iter "..i.."/"..tl.." ("..s..":"..l..") g: "..round(Score()-sc).." score: "..round(Score()))
end
local g=Score()-sscore
cherchevol() -- cherche la solution evoluable
--p("Total WalkeR gain: "..round(g))
end
---------------------------------------------
--Options for WalkeR
----------------------------------------------
--segStart=1 --start from (Default option for JET)
--segEnd=nil --end seg: nil=end of protein (Default option for JET)
--minLen=1 --minimum lws len
--maxLen=7 --segCntmum lws len
--minPpi=0.01 --minimum points gain per 2 wiggles, set 0.0001 in endgame :)
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
--3. LuckyLWS
--[[
LuckyLWS
search and LWS best scoring segments
options at end
]]--
function LuckyLWS(howmany, buddies, minppi) -- JET version
local function getpoints()
t={}
-- p("LuckyLWS Searching best scoring segments.")
local ss=Score()
selection.DeselectAll()
freeze.UnfreezeAll()
for i=segStart, segEnd do --fill score table
save.Quicksave(4)
selection.DeselectAll()
selection.Select(i)
local scs=Score()
WiggleAT(2,"lw")
--WiggleSimple(20,"lws")
--structure.LocalWiggleSelected(25)
local g=Score()-scs
t[#t+1]={i,g}
if g<keepTest then save.Quickload(4) end
end
-- p("LuckyLWS gain: "..round(Score()-ss))
return t
end
local function Sort(tab,items) -- bubble sorting - lowest on top, only needed items
if items>#tab then items=#tab end
for x=1,items do
for y=x+1,#tab do
if tab[x][2]<tab[y][2] then
tab[x],tab[y]=tab[y],tab[x]
end
end
end
return tab
end
if segEnd==nil then segEnd=segCnt end
behavior.SetClashImportance(1)
freeze.UnfreezeAll()
AllLoop()
recentbest.Save()
sscore=Score()
besttable=getpoints()
besttable=Sort(besttable,howmany)
if howmany>#besttable then howmany=#besttable end
for i=1, howmany do
if besttable[i][2]>=LWSonly then
local seg=besttable[i][1]
recentbest.Save()
wiggleBudies(seg, minppi, buddies)
end
end
local g=Score()-sscore
cherchevol() -- cherche la solution evoluable
--p("LuckyLWS gain: ".. round(g))
save.LoadSecondaryStructure()
end
keepTest = 0.001 --keep test points only when gain is more than --JET default, was 0.005
LWSonly = 0.001 --do lws only if test more than--JET default, was 0.005
--howmany = 5 --how many best
--buddies = 4 -- how many segments aside should be wiggled too
--minppi = 0.1 --minimum gain per wiggle iterations
--segStart=1 --JET general default
--segEnd=nil --JET general default
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
--4. Total lws
--totalLws(minlen,maxlen, minpp)
--minlen - minimum lenggh of sgmnts - if you have done lws by 1 and 2 you may want set it to 3
--maxlen - segCntmum lenght of sgments - more than 7 looks useless
--minppi - minimum gain per local wiggle iter
function totalLws(minlen,maxlen,minppi)
local function Freeze(start, len)
freeze.UnfreezeAll()
selection.DeselectAll()
for f=start, segCnt, len+1 do
if f<= segCnt then selection.Select(f) end
end
freeze.FreezeSelected(true, false)
end
local function wiggle(start,len,minppi)
if start>1 then
selection.DeselectAll()
selection.SelectRange(1,start-1)
lw(minppi)
end
for i=start, segCnt, len+1 do
selection.DeselectAll()
local ss = i+1
local es=i+len
if ss >= segCnt then ss=segCnt end
if es >= segCnt then es=segCnt end
selection.SelectRange(ss,es)
lw(minppi)
end
end
freeze.UnfreezeAll()
selection.DeselectAll()
behavior.SetClashImportance(1)
save.SaveSecondaryStructure()
AllLoop()
local ssc=Score()
--p("Starting Total LWS: "..ssc)
--p("Lenght: "..minlen.." to "..maxlen.." ;minimum ppi: "..minppi)
for l=minlen, maxlen do
for s=1, l+1 do
--p("Len: "..l.."..start point: "..s)
Freeze(s,l)
local sp=Score()
recentbest.Save()
wiggle(s,l,minppi)
local g=Score()-sp
GainAnother(g) --prints small gains
cherchevol() -- cherche la solution evoluable
end
end
--p("Total LWS gain: "..Score()-ssc)
save.LoadSecondaryStructure()
end
--minlen - minimum lenggh of sgmnts - if you have done lws by 1 and 2 you may want set it to 3
--maxlen - segCntmum lenght of sgments - more than 7 looks useless
--minppi - minimum gain per local wiggle iter
-------------------------------------------------------------
-------------------------------------------------------------
--5. Acid Tweaker v1.78 by Steven Pletsch
--modded by rav3n_pl;]
-- modded by BitSpawn, March 2012
-- and B.Kestemont, March 2013
-- v1.78: bug fixed with best score after rebuild
-- v2.00: LUAV2, thanks Timo
-- v2.1: bug fixed on rotamers, set default as in v1.78 by Bruno Kestemont
-- v2.2 Bug fixed on structure.WiggleAll (replaced by structure.WiggleSelected) by BK
-- here adapted version for JET!
-- 26/04/2015 added maximo
--START Archive in Notes, -- New 4/11/2014
function SelectNote(recipename)
store={}
store.label=recipename or "" -- edit here the recipe name
store.note_number=structure.GetCount()
for seg=structure.GetCount(),1,-1 do
if structure.GetNote(seg)~="" then break end
store.note_number=seg
end
print(string.format("Recording results in Note for segment %i",store.note_number))
store.starting_score=current.GetScore()
--structure.SetNote(store.note_number,string.format("(%s) %.3f + FSP",user.GetPlayerName(),store.starting_score))
end
SelectNote(recipeName) -- init with the recipe name here !!!
function WhriteNote(loop_nb) -- all inits are in SelectNote function
local loop_count= loop_nb or 1
structure.SetNote(store.note_number,string.format("(%s) %.3f + %s(%i) %.3f",user.GetPlayerName(),store.starting_score,store.label,loop_count,current.GetScore()))
end
--END Archive in Notes
--START quick save algorithm
function QuickShake()
--[[------------------------------------------------------------------------------------------------
-- Algorithm for faster shake
REFERENCES
1. N/A
Copyright (C) 2014 Seagat2011 <http://fold.it/port/user/1992490>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
$Id$
------------------------------------------------------------------------------------------------]]--
--[[
v1
- Inception
1.2
- Loops until nogain
]]--
local idx = 1
local idx2 = structure.GetCount ()
local hash = {}
local cs = current.GetScore ()
--print ( 'Quick Shake Algorithm v1.2 SG2011 - Current Score: '..cs )
local function New ( obj )
return obj -- pass-new-obj-by-value
end
local _gses = New ( current.GetSegmentEnergySubscore )
local function SmartShake ( iters )
local gain = true
while (gain) do
gain = false
for i=idx,idx2 do
local ci = _gses ( i,'clashing' )
if ci < _gses ( i,'hiding' ) and
ci < _gses ( i,'packing' ) and
ci < _gses ( i,'ideality' ) and
ci < _gses ( i,'sidechain') and
ci < _gses ( i,'bonding' ) and
ci < _gses ( i,'other' ) and
ci < _gses ( i,'reference') then
selection.Select ( i )
end -- test ci --
end -- loop --
if selection.GetCount () then
local css = current.GetScore ()
structure.ShakeSidechainsSelected ( iters )
selection.DeselectAll ()
if current.GetScore () > css then
gain = true
end -- test --
end -- test --
end -- loopf --
end
structure.SmartShake = SmartShake
structure.SmartShake ( 1 )
--print ( 'Done.' )
end
--END quick save algorithm
function ds(val)
if mutate==true then
if PROBABLEFILTER then behavior.SetSlowFiltersDisabled(OriginalFilterSetting) end -- new BK 8/4/2013, always back to user settings
structure.MutateSidechainsSelected(val+1)
else
--structure.ShakeSidechainsSelected(val)
QuickShake(1)
end
end
function CI(val)
global_ci=val
behavior.SetClashImportance(global_ci)
end
function WiggleSimple(val,how) -- with filter management
local val= val or 1 -- new 01/019/2014
local how= how or "wa"
if PROBABLEFILTER then behavior.SetSlowFiltersDisabled(true) end-- new BK 8/4/2013, always disable filter here
if how == "s" then ds(1)
elseif how == "wb" then structure.WiggleSelected(val, true, false) -- backbones
elseif how == "ws" then structure.WiggleSelected(val, false, true) -- sidechains
elseif how == "wa" then structure.WiggleSelected(val, true, true) -- all
elseif how== "lw" then structure.LocalWiggleSelected(val) -- new
end
if PROBABLEFILTER then behavior.SetSlowFiltersDisabled(OriginalFilterSetting) end -- new BK 8/4/2013, always back to user settings
end
function WiggleAT(ss, how, iters, minppi)
local valiter=2
local val=1
if fast==true then valiter=1 end
if how==nil then how="wa" end
if iters==nil then iters=6 end-- changed from 3 for NC 01/02/2014
if ((minppi==nil) or (minppi<0.01)) then
minppi=0.01
end
if global_ci==1.00 then val=valiter end
if iters>0 then
iters=iters-1
local sp=Score()
WiggleSimple(val,how)-- new function BK 8/4/2013 (includes filter management)
local ep = Score()
local ig=ep-sp
if how~="s" then
if ig > minppi then WiggleAT(ss, how, iters, minppi) end
end
end
end
function SelectSphere(sg, radius,nodeselect)
if nodeselect~=true then selection.DeselectAll() end
for i=1, segCnt do
if structure.GetDistance(sg,i)<radius then selection.Select(i) end
if sphere_worst==true then
if current.GetSegmentEnergyScore(i)<sphere_worst_value then selection.Select(i) end
end
end
end
function Fix(sg)
if fix_band==false then
return
end
-- selection.DeselectAll()
local nb=1
for i=1, segCnt do
dist=structure.GetDistance(sg,i)
if (dist<12 and dist>6) then
local cband=band.GetCount()
band.AddBetweenSegments(sg,i)
if cband<band.GetCount() then
band.SetGoalLength(nb, dist)
nb=nb+1
end
-- else if dist>12 then
-- selection.Select(i)
-- end
end
end
-- freeze.FreezeSelected(true,true)
-- selection.DeselectAll()
-- SelectSphere(sg,esfera)
WiggleSimple(5,"wa") -- 06/02/2014 all protein
band.DeleteAll()
-- freeze.UnfreezeAll()
end
function SaveBest() --adapted to JET
local sp=Score()
local g=sp-bestScore
if g>0 then
bestScore=sp
GainAnother(g)
cherchevol(g) -- cherche la solution evoluable
end
end
function usableAA(sn)
local usable=false
local sscore=current.GetSegmentEnergyScore(sn)
if sscore>minimo then
return usable -- donc false ici (true si score > minimo = 600)
end
if sscore<maximo then -- NEW BK 8/10/2013
return usable -- donc false ici (true si score < maximo)
end
if rebuild==true then
selection.DeselectAll()
selection.Select(sn)
structure.RebuildSelected(2)
usable=true
return usable
end
if #useThat>0 then
for i=1,#useThat do
if sn==useThat[i] then
usable=true
break
end
end
else
if #useOnly > 0 then
for i=1,#useOnly do
local ss=useOnly[i][1]
local se=useOnly[i][2]
for s=ss,se do
if s==sn then
usable=true
break
end
end
end
else
usable=true
if #doNotUse>0 then
for i=1,#doNotUse do
local ss=doNotUse[i][1]
local se=doNotUse[i][2]
for s=ss,se do
if s==sn then
usable=false
break
end
end
if usable==false then break end
end
end
if #skipAA>0 then
local aa=structure.GetAminoAcid(sn)
for i=1,#skipAA do
if aa==skipAA[i] then
usable=false
break
end
end
end
end
end
local se=segCnt
if segEnd~=nil then se=segEnd end
if sn<segStart or sn>se then usable=false end
return usable
end
function wiggle_out(ss)
CI(.6)
WiggleSimple(1,"wa") -- new function BK 8/4/2013
CI(1.)
WiggleAT(ss)
WiggleAT(ss,"s",1)
--selection.SelectAll()
CI(.6)
WiggleAT(ss)
CI(1.)
WiggleAT(ss)
recentbest.Restore()
SaveBest()
end
function getNear(seg)
if(Score() < g_total_score-1000) then
selection.Deselect(seg)
CI(.75)
WiggleSimple(1,"s") -- new function BK 8/4/2013
WiggleSimple(1,"ws") -- new function BK 8/4/2013
selection.Select(seg)
CI(1)
end
if(Score() < g_total_score-1000) then
if fix_band==true then
Fix(seg)
else
recentbest.Restore()
SaveBest()
return false
end
end
return true
end
function sidechain_tweak()
--p("Pass 1 of 3: Sidechain tweak")
p(i18.jet.tweak1)
for i=segStart, segEnd do
if usableAA(i) then
selection.DeselectAll()
selection.Select(i)
local ss=Score()
g_total_score = Score()
CI(0)
WiggleSimple(1,"s") -- new function BK 8/4/2013
CI(1.)
--p("Try sgmnt ", i)
SelectSphere(i, esfera)
if (getNear(i)==true) then
wiggle_out(ss)
end
end
end
end
function sidechain_tweak_around()
--p("Pass 2 of 3: Sidechain tweak around")
p(i18.jet.tweak2)
for i=segStart, segEnd do
if usableAA(i) then
selection.DeselectAll()
for n=1, segCnt do
g_score[n] = current.GetSegmentEnergyScore(n)
end
selection.Select(i)
local ss=Score()
g_total_score = Score()
CI(0)
WiggleSimple(1,"s") -- new function BK 8/4/2013
CI(1. )
-- p("Try sgmnt ".. i)
SelectSphere(i,esfera)
if(Score() > g_total_score - 30) then
wiggle_out(ss)
else
selection.DeselectAll()
for n=1, segCnt do
if(current.GetSegmentEnergyScore(n) < g_score[n] - 1) then
selection.Select(n)
end
end
selection.Deselect(i)
CI(0.1)
WiggleSimple(1,"s") -- new function BK 8/4/2013
SelectSphere(i,esfera,true)
CI(1.0)
if (getNear(i)==true) then
wiggle_out(ss)
end
end
end
end
end
-- essai d'amelioration JET 3:
function sidechain_manipulate() -- y a un bug, donne des scores negatifs !
--p("Dernire chance: manipulateur brutal des chaines latrales")
p(i18.jet.tweak3)
for i=segStart, segEnd do
if usableAA(i) then
selection.DeselectAll()
rotamers = rotamer.GetCount(i)
save.Quicksave(4)
if(rotamers > 1) then
local ss=Score()
--p("Sgmnt: ", i," rotamers: ",rotamers, " Score= ", ss)
for r=1, rotamers do
--p("Sgmnt: ", i," position: ",r, " Score= ", ss)
save.Quickload(4)
g_total_score = Score()
rotamer.SetRotamer(i,r)
CI(1.)
if(Score() > g_total_score - 30) then
SelectSphere(i,esfera)
wiggle_out(ss) -- ceci peut changer le nombre de rotamers
end
if rotamers > rotamer.GetCount(i) then break end --si nb de rotamer a change
end
end
end
recentbest.Restore()-- car les rotamers ont pu tout casser.
end
end
-- fin d'essai d'amelioration JET 3
useThat={ --only segments what have to be used OVERRIDES all below
--18,150,151,205,320,322,359,361,425,432,433 --382
}
useOnly={ --ranges what have to be used OVERRIDES BOTH LOWER OPTIONS
--{12,24},
--{66,66},
}
doNotUse={ --ranges that should be skipped
--{55,58},
--{12,33},
}
skipAA={ --aa codes to skip
'a',
'g',
}
--option to easy set start and end of AT work to
--segStart=1 -- general option --1st segment
--segEnd=nil --end of protein if nil
--sphere_worst=false -- include worst segments in sphere or not, added to general option
--sphere_worst_value=0 --added to general option . Intervient dans SelectSphere() pour decider a partir de quel score selectionner le segment voisin
function AcidTweeker(patience, buddies, risk) -- JET version by BK
--g_total_score = Score() -- recent best to compare to and see if score was improved --essayer de cacher-----
g_score = {} -- array of segment scores for comparisons (total for segment)
--segCnt=segCnt-1 -- uncomment for lingard puzzles only!
esfera=buddies
-- for patience =1 and precision = 1 , default values:
rebuild=false -- for very end in a puzzle, rebuild segment before tweak
fix_band=false -- for trying with the worst segments
fast=true
manipulate=false -- test rotamers
if patience < 2 then manipulate=false end -- no manipulate rotamers (default)
if patience == 2 then manipulate=true end -- fast manipulate for 2
if patience > 2 then fast=false end -- slow only for 3 and 5+
if patience == 4 then manipulate=true end -- slow manipulate for 4
if risk < 2 then fix_band=false end -- fix band only for 2
if risk == 2 then fix_band=true rebuild=false end -- fix band only for 2
if risk > 2 then fix_band=false rebuild=true end -- rebuild only for 3 and 5+
if risk == 4 then fix_band=true rebuild=true end -- rebuild and fix band for 4
-- JET default options
minimo=510 -- score for working with worst segments. Don't use, usually worst segs have no rotts
mutate=false -- Don't use, very bad results yet (TODO)
maximo=-10
-- segStart=1
-- segEnd=segCnt
ini_score=Score()
-- The original recipe started here
CI(1.00)
recentbest.Restore()
save.Quicksave(3)--in save 3 always best solution. Load in case of crash.
s1=Score()
sidechain_tweak()
s2=Score()
--p("Gain Tweak: "..round(s2-s1))
p(i18.jet.tweakgain1..round(s2-s1))
sidechain_tweak_around()
s3=Score()
-- p("Gain Tweek Around: "..round(s3-s2))
p(i18.jet.tweakgain2..round(s3-s2))
if manipulate==true then
sidechain_manipulate() -- y a un bug, donne des scores negatifs !
s4=Score()
if s4-s3 <0 then recentbest.Restore() end --against the bug !!!
-- p("Gain Manipulate: "..round(s4-s3).." (ignor si <0)")
p(i18.jet.tweakgain3..round(s4-s3)..i18.jet.tweakgain3nil)
end
selection.SelectAll() -- or 2 lines in one structure.WiggleAll(4,true,true)
--WiggleSimple(1) -- new function BK 8/4/2013
WiggleAT(4)
WiggleAT(2,"ws")
--WiggleSimple(1,"ws") -- new function BK 8/4/2013
selection.SelectAll()
WiggleAT(4)
--WiggleSimple(10,"wa") -- new function BK 8/4/2013
recentbest.Restore()
s5=Score()
--p("Total Acid Tweeker gain: "..s5-s1)
end
-------------------------------------------------------------
-------------------------------------------------------------
-------------------------------------------------------------
--5b. Worm LWS v2 & other SD_Multiwalk functions 26/4/2015
--adapted to longer version, translated to Lua 2
function Worm(power,reserve1,minppi) -- alternative wiggle strategy, no filter management
--if sEnd==nil then sEnd=segCount end
local power=power or 1
local reserve1=reserve1 or 1
local minppi=minppi or 0 -- ici, il vaut mieux laisser 0
local pattern={}
local patternS={2,5,11,3,13,4,7,1,6,2,8,5} --how many segments at once to LWS
local patternL={2,5,11,3,13,4,7,1,6,2,8,5,12,3,10,4,7,1,6,2,9,5,14,3,5,1,8,2,13,3,7} --how many segments at once to LWS
if power ==1 then
pattern=patternS
else
pattern=patternL
end
AllLoop()
--reset_recent_best()
recentbest.Save()
--set_behavior_clash_importance(1)
CI(1.00)
--quicksave(3)
save.Quicksave(33)
local ss=Score()
for w=1,#pattern do
lenWorm=pattern[w]
local sw=Score()
--p("Starting Worm of len ",len,", score: ",round(Score()))
for s=segStart,segEnd-lenWorm+1 do
--deselect_all()
selection.DeselectAll()
selection.SelectRange(s,s+lenWorm-1)
--select_index_range(s,s+len-1)
lwWorm(minppi) -- no filter management !
end
--p("Pattern gain: ",round(Score()-sw))
--quicksave(3)
save.Quicksave(33)
end
selection.DeselectAll()
--load_structure()
save.LoadSecondaryStructure()
--p("Total Worm gain: ",round(Score()-ss))
end
function KrogWalkerV4(minseg, maxseg, threshold) -- used
--
print("Starting Krog walker V4...")
-- *** SET OPTIONS HERE ***
local minseg= minseg or 1
local maxseg= maxseg or 4
local threshold= threshold or 0.001
-- How many segments to wiggle. Starts at min, stop at max.
-- Krog recommends 1-4.
min_segs_to_wiggle = minseg -- 1
max_segs_to_wiggle = maxseg-- 4
-- How much the score must improve at each iteration to try that section again.
-- Krog recommends 0.01 for early, 0.001 mid and 0.0001 late - get all you can!
score_condition = threshold --0.001
-- If true, do a smoother, global wiggle - much slower but might squeeze extra points
should_global_wiggle = false
-- Set to true if you want it to run forever - good for overnighting
-- Krog recommends a SUPER low score condition if this is true.
should_run_forever = false
-- **********************************************************************
-- *** Dont edit below this line unless you know what you're doing :) ***
-- **********************************************************************
function wiggle_walk(section_size, score_thresh, global)
total_gain = 0;
recentbest.Restore()
behavior.SetClashImportance(1)
selection.DeselectAll()
freeze.UnfreezeAll()
segs = structure.GetCount()
for i = 1, section_size - 1 do
selection.Select(i)
end
for i = section_size, segs do
selection.Select(i)
gain = score_thresh
while gain >= score_thresh do
last_score = current.GetScore()
if global then
structure.LocalWiggleAll(40/section_size)
else
structure.LocalWiggleSelected(8)
recentbest.Restore()
end
gain = current.GetScore() - last_score
total_gain = total_gain + gain
--print("Section ", i - section_size + 1, "/", segs - section_size + 1, " Improvement: ", gain)
--print(" Total Improvement: ", total_gain)
end
selection.Deselect(i - section_size + 1)
end
end -- wiggle walk
run_condition = true
while run_condition do
run_condition = should_run_forever
for j = min_segs_to_wiggle, max_segs_to_wiggle do
wiggle_walk(j, score_condition, should_global_wiggle)
end
end
end -- Krog Walker
function M3wigglwSequence(sidechains_flag,max_iterations,threshold) -- used
--
print("starting M3 Wiggle sequence...")
-- Foldit Script "Wiggle Sequence"
-- 01-09-2010
-- V1.0
-- MooMooMan
-- If 1 then wiggle sidechains.
local sidechains_flag = sidechains_flag or 0
local threshold = threshold or 0.0001
-- If 1 then shake
shake_flag = 0
-- Set number of wiggle cycles per iteration
wiggle_cycles = 5
-- Set number of iterations to gain points.
local max_iterations = max_iterations or 10
-- Set termination threshold.
--threshold = 0.0001
-- Obtain the number of segments in the protein.
segments = structure.GetCount()
-- Maximum number of segments to wiggle.
max_wiggle = 5
-- Get the starting score.
initial_score = current.GetScore()
-- print a title.
--print("Wiggle Sequence")
-- Save the current structure in slot 10
save.Quicksave(10)
-- Reset the recent best so we can use crtl N
recentbest.Restore()
-- Loop for the wiggle length
for seq = 1, max_wiggle do
-- Loop for the selected segments.
for sel = 1, (segments-seq) do
--print("Seq ", seq, "/", max_wiggle, " : AA ", sel, "/", segments)
-- Make sure nothing is selected.
selection.DeselectAll()
-- Iterate over the segments we want to select.
for group = 0, seq do
selection.Select(sel + group)
end
-- Get the score before changing.
scoreBefore = current.GetScore()
scoreStart = current.GetScore()
scoreAfter = scoreBefore
-- Now wiggle those segments selected.
structure.LocalWiggleSelected(wiggle_cycles)
-- Shake if selected.
if (shake_flag == 1) then
structure.ShakeSidechainsSelected(1)
end
-- Wiggle sidechains if selected
if (sidechains_flag == 1) then
structure.WiggleAll(1,false,true)
end
-- Get score after operations.
scoreAfter = current.GetScore()
-- Check to see if we should iterate to get more points.
iteration_count = 0
while( ((scoreAfter - scoreBefore) > threshold) and (iteration_count < max_iterations)) do
--print ("Iterating... ", iteration_count, "/", max_iterations)
-- Reset the recent best structure..
recentbest.Restore()
-- Reset the before score.
scoreBefore = scoreAfter
-- Now wiggle those segments selected.
structure.LocalWiggleSelected(wiggle_cycles)
-- Score after operations.
scoreAfter = current.GetScore()
-- Test to see if we should keep the structure.
if( (scoreAfter - scoreBefore) > threshold) then
recentbest.Restore()
else
recentbest.Restore()
end
iteration_count = iteration_count + 1
end
-- Shake if selected.
if (shake_flag == 1) then
structure.ShakeSidechainsSelected(1)
end
-- Wiggle sidechains if selected
if (sidechains_flag == 1) then
structure.WiggleAll(1,false,true)
end
if ((current.GetScore() - scoreStart) > threshold) then
--print("Gain +", current.GetScore() - scoreStart)
end
recentbest.Restore()
end
end
end -- M3 wiggle sequence
function MoonWalker(threshold, par2, par3) -- used
print("Starting moon walker...")
-- step walker refresh. Original ideas from Datstandin.
-- updated by smith92clone 31May2010
-- Perform a local wiggle /w campon for each segment, with 1, 2 and 3 segments selected
-- If a wiggle increases in points, backup one segment and wiggle again. Could run a long time.
g_segments = structure.GetCount()
function reset_protein()
behavior.SetClashImportance(1)
selection.DeselectAll()
freeze.UnfreezeAll()
end -- reset protein
function get_protein_score(segment_count)
return current.GetScore()
end -- get protein score
function wiggle_it_out(wiggle_params)
selection.DeselectAll()
selection.SelectAll()
structure.WiggleAll(wiggle_params.sideChain_count, false, true)
structure.ShakeSidechainsSelected(wiggle_params.shake)
structure.LocalWiggleAll(wiggle_params.all_count)
recentbest.Restore()
end --wiggle it out
function do_the_local_wiggle_campon(first,last,wiggle_params)
selection.DeselectAll()
if last > g_segments then
last = g_segments
end
selection.SelectRange(first,last)
local end_score = get_protein_score()
local points_increased = false
local beginning_score = end_score
repeat
start_score = end_score
structure.LocalWiggleSelected(wiggle_params.local_wiggle)
recentbest.Restore()
end_score = get_protein_score()
--print(" start ",start_score," end ", end_score)
until end_score < start_score + wiggle_params.local_tolerance
if beginning_score + wiggle_params.local_tolerance < end_score then
points_increased = true
end
--recentbest.Restore()
return points_increased
end --do_the_local_wiggle_campon
function step_wiggle(start,finish,wiggle_params)
local i
local reset
local rewiggle_increment = 1 -- points
local rewiggle_score = get_protein_score() + rewiggle_increment
i = start
while i <= finish do
local j
local saved_changed
local points_changed = false
for j = 1,3 do
--print("seg:",i," of ",finish," wiggle Length: ",j)
saved_changed = do_the_local_wiggle_campon(i,i+j-1,wiggle_params)
if saved_changed then
points_changed = true
end
end
if points_changed then
reset = i - 1 -- we want to go back to the previous segment
if reset < start then
reset = start
end
for j=1,3 do
--print("retry seg:",reset," of ",finish," wiggle Length: ",j)
do_the_local_wiggle_campon(reset,reset+j-1,wiggle_params)
end
reset = reset + 1
if reset <= i then
-- let's not get ahead of ourselves. Only really an issue when we are retrying 1
for j=1,3 do
--print("retry seg:",reset," of ",finish," wiggle Length: ",j)
do_the_local_wiggle_campon(reset,reset+j-1,wiggle_params)
end
end
end
local new_score = get_protein_score()
if new_score > rewiggle_score then
wiggle_it_out(wiggle_params)
rewiggle_score = new_score + rewiggle_increment
end
i = i + 1
end
end -- step wiggle
reset_protein()
recentbest.Restore()
wiggle_params = {}
wiggle_params.local_wiggle = 12
wiggle_params.local_tolerance = threshold
wiggle_params.sideChain_count = 15
wiggle_params.shake = 5
wiggle_params.all_count = 15
step_wiggle(1,g_segments,wiggle_params)
end -- moon walker
function PiWalkerCamponV2(threshold, par2, par3)
--
print("Starting pi walker campon V2...")
-- rewrite of pi_walker_campon
-- author srssmith92 6June2010
-- (LF/TAB converted)
g_segments = structure.GetCount()
function mynextmode(number,maximum)
number = number + 1
if number > maximum then
number = 1
end
return number
end -- mynextmode
function get_protein_score(segment_count)
return current.GetScore()
end --get protein score
function rotate_pattern(pattern_list)
local last = #pattern_list
local i
if last > 1 then
local pattern_save = pattern_list[1]
for i = 1, last do
pattern_list[i] = pattern_list[i+1]
end
pattern_list[last] = pattern_save
end
return pattern_list
end -- rotate pattern
function unfreeze_protein()
freeze.UnfreezeAll()
end -- unfreeze protein
function freeze_segments(start_index,pattern_list)
unfreeze_protein()
local pattern_length = #pattern_list
local current_segment = start_index
local current_pattern = 1
selection.DeselectAll()
while current_segment < g_segments do
selection.Select(current_segment)
current_segment = current_segment + pattern_list[current_pattern]
current_pattern = mynextmode(current_pattern,pattern_length)
end
freeze.FreezeSelected(true,true)
end -- freeze segments
function do_the_local_wiggle_campon(first,last,wiggle_params)
selection.DeselectAll()
selection.SelectRange(first,last)
local end_score = get_protein_score()
local points_increased = false
local beginning_score = end_score
repeat
start_score = end_score
structure.LocalWiggleSelected(wiggle_params.local_wiggle)
recentbest.Restore()
end_score = get_protein_score()
--print(" start ",start_score," end ", end_score)
until end_score < start_score + wiggle_params.local_campon_tolerance
if beginning_score + wiggle_params.local_campon_tolerance < end_score then
points_increased = true
end
--recentbest.Restore()
return points_increased
end -- do the local wiggle campon
function do_a_local_wiggle(current_pattern, current_segment, end_segment, last_current_segment, last_end_segment, pattern_list, wiggle_params)
local saved_changed
saved_changed = do_the_local_wiggle_campon(current_segment, end_segment, wiggle_params)
if saved_changed then
-- now back up the pattern list
if last_current_segment ~= nil then
--print("retry segs: ", last_current_segment, " to ", last_end_segment)
do_the_local_wiggle_campon(last_current_segment, last_end_segment, wiggle_params)
--print("retry segs: ", current_segment, " to ", end_segment)
do_the_local_wiggle_campon(current_segment, end_segment, wiggle_params)
end
end
last_current_segment = current_segment
last_end_segment = end_segment
current_segment = end_segment + 2
end_segment = current_segment + pattern_list[current_pattern] - 2
current_pattern = mynextmode(current_pattern,pattern_length)
return current_pattern, current_segment, end_segment, last_current_segment, last_end_segment
end -- do a local wiggle
function local_wiggle_segments(first_frozen_segment,pattern_list,wiggle_params)
local current_segment = 0
local current_pattern = 1
local end_segment
local pattern_length = #pattern_list
local last_current_segment, last_end_segment
if first_frozen_segment == 1 then
current_segment = 2
end_segment = current_segment + pattern_list[1]-2
current_pattern = mynextmode(current_pattern,pattern_length)
else
current_segment = 1
end_segment = first_frozen_segment - 1
end
local saved_changed
repeat
--print("segs: ", current_segment, " to ", end_segment)
current_pattern, current_segment, end_segment, last_current_segment, last_end_segment = do_a_local_wiggle(current_pattern, current_segment, end_segment, last_current_segment, last_end_segment, pattern_list, wiggle_params)
until end_segment > g_segments
if current_segment <= g_segments then
--print("last segs: ", current_segment, " to ", end_segment)
do_a_local_wiggle(current_pattern, current_segment, g_segments, last_current_segment, last_end_segment, pattern_list, wiggle_params)
end
end -- local wiggle segments
function freeze_wiggle(pattern_list, wiggle_params)
local i
for i = 1,pattern_list[1] do
freeze_segments(i, pattern_list)
recentbest.Restore()
local_wiggle_segments(i, pattern_list, wiggle_params)
end
end -- freeze wiggle
function verify_pattern_list(pattern_list, maximum)
if pattern_list == nil or maximum == nil then
return false
end
local result = true
pattern_length = # pattern_list
local count = 0
for count = 1, pattern_length do
if pattern_list[count] == 1 or pattern_list[count] > maximum then
result = false
break
end
end
return result
end --verify pattern list
pattern_list = {2,3,3,4} -- distance between frozen segments. Change this to what you want. Experiment 2,2,3,3,4,4, whatever
pattern_length = #pattern_list
pattern_list_ok = verify_pattern_list(pattern_list,g_segments)
wiggle_params = {}
wiggle_params.local_wiggle = 12
wiggle_params.local_campon_tolerance = threshold
if pattern_list_ok then
for pattern_count = 1, pattern_length do
freeze_wiggle(pattern_list, wiggle_params)
end
unfreeze_protein()
else
--print("Pattern list contains a 1, or an element greater than ", g_segments, " quitting")
end
end --pi walker campon
function Power_Walker_fn(g_startSeg, par2, par3) -- used --param not used
print("Starting Power Walker...")
g_segments = structure.GetCount() --total number of segments in puzzle, last seg
g_total_score = 0 -- recent best to compare to and see if score was improved
local g_startSeg=g_startSeg or 1 -- segment to start with
local par2=par2 or 0
local par3=par3 or 0
----------------------------- Begin walk_it() -------------------------------
-- Global Variable Dependencies: g_total_score
-- Function Dependencies: last_seg(), next_seg()
function walk_it(seg,step,time)
selection.DeselectAll()
selection.SelectRange(seg, (seg+step))
g_total_score = current.GetScore()
structure.LocalWiggleSelected(time)
recentbest.Restore()
if((current.GetScore() - g_total_score) >= 0.05)then
last_seg(seg, step,time)
else
next_seg(seg, step,time)
end
end
----------------------------- Begin next_seg() -------------------------------
-- Global Variable Dependencies: N/A
-- Function Dependencies: walk_it()
function next_seg(seg, step,time)
if((seg + step) == g_segments)then
return nil
else
if(step == 1)then
step = 2
else
step = 1
seg = seg + 1
end
end
walk_it(seg, step,time)
end
----------------------------- Begin last_seg() -------------------------------
-- Global Variable Dependencies: N/A
-- Function Dependencies: N/A
function last_seg(seg, step,time)
if(step == 2)then
step = 1
else
seg = seg - 1
end
if(seg == 0)then
seg = 1
end
walk_it(seg, step,time)
end
---------------------------- Begin end_it_all() ----------------------------------
function end_it_all()
print (finished)
end
--------------------------- Script Execution Begin -----------------------------
g_total_score = current.GetScore()
selection.DeselectAll()
freeze.UnfreezeAll()
recentbest.Restore()
walk_it(g_startSeg,1,5)
behavior.SetClashImportance(0.8)
selection.SelectAll()
structure.LocalWiggleAll(1)
behavior.SetClashImportance(1.)
structure.LocalWiggleAll(5)
walk_it(g_startSeg,1,10)
behavior.SetClashImportance(0.8)
selection.SelectAll()
structure.LocalWiggleAll(1)
behavior.SetClashImportance(1.)
structure.LocalWiggleAll(5)
walk_it(g_startSeg,1,20)
behavior.SetClashImportance(0.8)
selection.SelectAll()
structure.LocalWiggleAll(1)
behavior.SetClashImportance(1.)
structure.LocalWiggleAll(5)
walk_it(g_startSeg,1,30)
end -- Power_Walker_fn
function s_ws_wa_whatever(par1, par2, par3) -- used -- par not used
print("Starting s_ws_wa_whatever...")
selection.SelectAll()
i=0
while true do
behavior.SetClashImportance(1)
i=i+1
ss=current.GetScore()
--print("Iter ",i," start at score ",ss)
structure.ShakeSidechainsSelected(1)
structure.WiggleAll(1,false,true)
structure.LocalWiggleAll(1)
behavior.SetClashImportance(0.2)
structure.MutateSidechainsSelected(1)
behavior.SetClashImportance(1)
structure.LocalWiggleAll(2)
gain=current.GetScore()-ss
--print("Gain: ",gain)
if gain<0.1 then break end
end
end -- s_ws_wa_whatever
function SdHowMany(startNum, howmany, par3)
--startNum is the HH to start with
--howmany is the highest HH to execute. Range is from 2 to numSegs/2
print("Starting SdHowmany from ", startNum, " to ", howmany, " ...")
--[[
SdWalkAllHH version 1.0
Roughly LUA HH2 through HH?? executed consecutively
This code is based on a LUA version of the Helix Hula scripts.
]]--
function HH(h,segFirst,segLast) --this is based on a LUA version of the HelixHula code
for g=0,h-1 do --for each starting position
--print(' Beginning with position ',g+1)
recentbest.Restore()
for j=segFirst+g,segLast,h do --do a local wiggle on each of the segments
k=j-h+1
m=j+h-1
if k<1 then k=1 end
if m>segLast then m=segLast end
selection.SelectRange(k,m)
structure.LocalWiggleSelected(3)
selection.DeselectAll()
recentbest.Restore()
end
end
selection.SelectAll() --reset all segments to a loop
structure.SetSecondaryStructureSelected('L')
selection.DeselectAll()
structure.ShakeSidechainsSelected(1) --shake and wiggle it out
structure.LocalWiggleAll(5)
structure.ShakeSidechainsSelected(1)
structure.LocalWiggleAll(25)
end --HH
function SdWalkAllHH(sn, hm)
--sn is the starting HH. hm is the highest HH to execute. Range is from 2 to numSegs/2
behavior.SetClashImportance(1)
freeze.UnfreezeAll()
band.DeleteAll()
selection.SelectAll() --set everything to a loop
structure.SetSecondaryStructureSelected('L')
selection.DeselectAll()
recentbest.Restore()
scoreStart=current.GetScore()
--print('Starting at score ', scoreStart)
segF=1 --the first segment number to be processed
segL=structure.GetCount() --the last segment number to be processed
for hhn=sn,hm do --main loop, each iteration is roughly one HH
--print('Executing HH',hhn)
HH(hhn,segF,segL)
recentbest.Restore()
--print('Score at end of HH', hhn, ' is ', current.GetScore())
end
--print('Score improved by: ', current.GetScore() - scoreStart)
--print('And all done!')
end -- SdWalkAllHH
SdWalkAllHH(startNum, howmany)
end -- SdHowMany
function Stabilize_fn(par1, par2, par3)
print("Starting Stabilize 3.0.7...")
segCount=structure.GetCount()
function Score()
return current.GetScore()
end
function Round(x)--cut all afer 3-rd place
return x-x%0.001
end
function Down(x)--cut all afer comma
return x-x%1
end
function SelectSphere(sg, radius)
selection.DeselectAll()
for i=1, segCount do
if structure.GetDistance(sg,i)<radius then selection.Select(i) end
end
end
function PartialScoreTable() --fill score table
local scr={}
for i=1, segCount do
scr[i]=current.GetSegmentEnergyScore(i)--get partial scores
end
return scr
end
function GetWorst(sctbl)
local min=sctbl[1]
local wrst=1
for x=2, #sctbl do
if sctbl[x]<min then
wrst=x
min=sctbl[x]
end
end
sctbl[wrst]=99999
return wrst
end
function Gibaj(jak, iters, minppi) --score conditioned recursive wiggle/shake
if jak==nil then jak="wa" end
if iters==nil then iters=6 end
if minppi==nil then minppi=0.4 end
if iters>0 then
iters=iters-1
local sp=Score()
if jak == "s" then structure.ShakeSidechainsSelected(1)
elseif jak == "wb" then structure.WiggleAll(1,true, false)
elseif jak == "ws" then structure.WiggleAll(1,false,true)
elseif jak == "wa" then structure.LocalWiggleAll(1)
end
local ep = Score()
local ig=ep-sp
if ig > minppi then Gibaj(jak, iters, minppi) end
end
end
function wss(minppi)
repeat
local ss=Score()
structure.WiggleAll(1,false,true)
structure.ShakeSidechainsSelected(1)
g=Score()-ss
until g<minppi
end
function wig(mingain) --score conditioned local wiggle,
repeat --wiggles selected segments
local ss=Score()
structure.LocalWiggleSelected(2)
local wg=Score()-ss
if wg<0 then
recentbest.Restore()
end
until wg<mingain
end
function StabilizeWorstSphere(sgmnts)
sgmnts=Down(sgmnts)
recentbest.Restore()
sctbl=PartialScoreTable()
for i=1, sgmnts do
local found=flase
local wrst=0
wrst=GetWorst(sctbl)
--P(sgmnts+1-i," more spheres to fix. Now fixing: ",wrst)
selection.DeselectAll()
selection.Select(wrst)
wig(20)
SelectSphere(wrst,11)
wss(1)
wig(20)
end
end
function Stabilize(maxLoops)
behavior.SetClashImportance(1)
local sstart= Score()
--P("Starting score: ",Round(sstart))
for iters = 1, maxLoops do
local ss=Score()
selection.SelectAll()
wss(2)
StabilizeWorstSphere(segCount/20)
local gain=Score()-ss
--P("WSS LWS loop ",iters," gain: ",Round(gain))
if gain<200 then break end
end
selection.SelectAll()
repeat
local ss=Score()
wss(2)
Gibaj()
local g=Score()-ss
until g<20
send=Score()
--P("Total improved by: ", Round(send-sstart), " points.")
--P("End score: ", Round(send))
end
maxLoops=10
Stabilize(maxLoops)
end -- Stabilize_fn
function walker_1point1_fn(minlen,maxlen,minppi)
print("Starting Walker 1.1...")
segCount = structure.GetCount()
function Score()
return current.GetScore()
end
bestScore=Score()
function round(x)--cut all afer 3-rd place
return x-x%0.001
end
function SelectSphere(sg, radius,nodeselect)
if nodeselect~=true then selection.DeselectAll() end
for i=1, segCount do
if structure.GetDistance(sg,i)<radius then selection.Select(i) end
end
end
function Gibaj(jak, iters, minppi) --score conditioned recursive wiggle/shake
if jak==nil then jak="wa" end
if iters==nil then iters=6 end
if minppi==nil then minppi=0.04 end
if iters>0 then
iters=iters-1
local sp=Score()
if jak == "s" then structure.ShakeSidechainsSelected(1)
elseif jak == "wb" then structure.WiggleAll(1,true, false)
elseif jak == "ws" then structure.WiggleAll(1,false,true)
elseif jak == "wa" then structure.LocalWiggleAll(1)
end
local ep = Score()
local ig=ep-sp
if ig > minppi then Gibaj(jak, iters, minppi) end
end
end
function wig(mingain) --score conditioned local wiggle,
repeat --wiggles selected segments
local ss=Score()
structure.LocalWiggleSelected(2)
local se=Score()
local wg=se-ss
if wg<0 then
recentbest.Restore()
end
until wg<mingain
end
function wsw(minppi)
behavior.SetClashImportance(1)
local nows=false
repeat
local ss=Score()
if nows==false then structure.WiggleAll(1,false,true) end
if shake==true then structure.ShakeSidechainsSelected(1) end
local shs=Score()
structure.WiggleAll(2, false, true)
local ws=Score()
local g=ws-ss
nows=true
if ws-shs<minppi/10 then break end
until g<minppi
end
function test()
local gain = Score() - bestScore
if gain > 0 then
--print("Improved by: ", round(gain))
bestScore = Score()
save.Quicksave(3)
elseif gain<0 then
save.Quickload(3)
end
end
function Walker()
local ss=Score()
if endS==nil then endS=segCount end
recentbest.Restore()
save.Quicksave(3)
behavior.SetClashImportance(1)
--print("Walker started.")
for l=minlen,maxlen do
for i=startS, endS-l do
--print("Sgmnt ",i," len: ",l)
selection.DeselectAll()
selection.SelectRange(i,i+l-1)
if doWSW then wsw(minppi) end
wig(minppi)
test()
end
end
--print("Totoal improved by: ",round(Score()-ss))
end
local minppi=minppi or 0.0002
startS=1 --start segment to walk
endS=nil --end segment to walk -nil=end of protein
local minlen=minlen or 1
local maxlen=maxlen or 13
doWSW=true --false --set to true if it have to shake/wiggle sidechains too
local shake=false
Walker()
end -- walker_1-1_fn
-------------------------------------------------------------
-------------------------------------------------------------
-------------------------------------------------------------
--6. JET (Join Evolver team) by Bruno.kestemont helped by Jean-Bob
--A combination of various LWS recipes
--Starting from most efficient to slowest for night run
------------------------
--JET call and safety function
------------
function JET(funcName, func, param1, param2, param3)
if nextskip==funcName or oldskip== funcName then
p(i18.jet.skipping..funcName)
oldskip=nextskip -- will be skipped a second time
nextskip="" -- 2 skips is enough
skipthis=true
end -- saute une recette non gagnante 2 fois
if interuptor==false and skipthis==false then --pour interrompre en debut de puzzle, JET ne jouant qu'un role initial
local startRecTime=os.time() -- en secondes entieres
CI(1)
--p(funcName.." (".. param1..", ".. param2..", ".. param3..") en cours ...")
p(i18.jet.running1..funcName.." (".. param1..", ".. param2..", ".. param3..")"..i18.jet.running2.."...")
save.SaveSecondaryStructure()
recentbest.Save()
bestScore=Score() -- necessaire pour savebest()
func(param1, param2, param3)
local score=Score()
local RecTime=(os.time()-startRecTime)/60 -- en minutes
if score<=maxScore then
--p("... ne gagna plus rien en "..RecTime.." minutes")
p(i18.jet.nogain..RecTime.." minutes")
recentbest.Restore()
nextskip=funcName -- NEW 20/6/2013 to skip this function twice
elseif score>maxScore then
if score<maxScore +0.001 then -- NEW 19/7/2013 to skip this function twice
nextskip=funcName
end
gainRecipe=score-maxScore
maxScore= score
save.Quicksave(3)
--print("... gagna ".. round(gainRecipe).." points en "..down(RecTime).." minutes")
p(i18.jet.gain1..round(gainRecipe)..i18.jet.gain2..down(RecTime).." minutes")
end
save.LoadSecondaryStructure()
JETgain=maxScore-startingscore
JETtime=(os.time()-startTime)/60 -- en minutes
--p("Score actuel ".. round(score)..". >>>>Gain JET = ".. round(JETgain).."<<<< en "..down(JETtime).."'")
p(i18.jet.score.. round(score)..i18.jet.gainT.. round(JETgain)..i18.jet.gainin..down(JETtime).."'")
testinterupt(JETgain)
forecastGain()
comptetour=comptetour+1
end
skipthis=false
end
--------------------------------------------------------------
--Documentation FR
--[[ 1.PreciseLWS(howmany, buddies, minppi)
-- >Cherche et secoue les pires segments
-- howmany = combien de pires segments
-- buddies = nombre de segments adjascents
-- minppi = gain minimum par iteration LWS
-- usage = (5,4,0.1) -- les valeurs par defaut les plus efficaces ]]--
--[[2.WalkeR(minLen, maxLen, minPpi)
-- >Secoue des segments adjascents dans un ordre aleatoire
-- minLen= longueur minimum pour LWS
-- maxLen= longueur segCntmum pour LWS
-- minPpi= gain minimum par iteration (boucle sarrete quand gain plus petit)
-- usage = (1,7,0.1) -- les valeurs par defaut les plus efficaces ]]--
--[[3. LuckyLWS(howmany, buddies, minppi)
-- >Cherche et secoue les meilleurs segments, apres un test
-- howmany = combien de meilleurs segments
-- buddies = nombre de segments adjascents
-- minppi = gain minimum par iteration LWS
-- usage = (5,4,0.1) -- les valeurs par defaut les plus efficaces ]]--
--[[4. totalLws(minlen,maxlen, minppi)
-- minlen= longueur minimum pour LWS
-- maxlen= longueur segCntmum pour LWS
-- minppi = gain minimum par iteration (boucle sarrete quand gain plus petit)
-- usage = (1,7,0.1) -- les valeurs par defaut les plus efficaces ]]--
--[[5. AcidTweeker(patience, buddies, risk)
-- patience=rapide si petit-- 1=rapide; 2=bruteforce rapide ; 3= lent ; 4=bruteforce lent
-- buddies = nombre de segments adjascents
-- risk=faible si petit -- 1=defaut; 2=bandes ; 3= rebuild ; 4=bandes et rebuild
--usage= (1, 8, 3) -- les valeurs par defaut les plus efficaces ]]--
--[[5b. Worm(power,reserve1,minppi)
-- power = normal ou long 1 ou 2
--reserve1= reserve au cas ou
--minppi= minppi
--usage= (1) ]]--
-- KrogWalkerV4(minseg, maxseg, threshold) -- 1,4,0.0001
-- SdHowMany(startNum, howmany,anythingelse) -- 2,4,(0, not used)
-- M3wigglwSequence(sidechains_flag,max_iterations,threshold) -- 0,10,0.0001
-- Power_Walker_fn(g_startSeg, par2, par3) -- 1,0,0
-- s_ws_wa_whatever(par1, par2, par3) -- 0,0,0
-- MoonWalker(threshold, par2, par3) -- 0.0001,0,0
-- PiWalkerCamponV2(threshold, par2, par3) -- 0.0001,0,0
-- Stabilize_fn() -- 0,0,00
-- walker_1point1_fn -- 1,13,0.002
--[[6. JET(func, param1, param2, param3)
-- func = est le nom dune des fonctions ci-dessus -- par example AcidTweeker
-- param1= le premier parametre de la fonction appelee
-- param2= le deuxieme parametre de la fonction appelee
-- param3= le dernier parametre de la fonction appelee
--usage= ("Total LWS".. totalLws, 1, 7,0.1) -- les valeurs les plus efficaces ]]--
----Start module several steps to be saved--------------
function cherchevol() --identifie les passages d'unite
local score=Score() --evolbase est le down du depart
local passeUnite=score-evolbase --incrementer jusque passage de la prochaine unite
if passeUnite<1 then --avant de passer la premiere unite
save.Quicksave(11) --mise a jour jusqu'au plus haut decimal possible
else
evolbase=down(score) --eliminer les decimales du futur evoluable
JETevolver() -- cascade sur base du dernier slot 11 sauve juste en-dessous de l'unite ou sauve en cas de grands gains
end
end
function JETevolver()
--print("Sauvegarde pour partage evoluable")
save.Quickload(10) --reprendre l'avant derniere version
save.Quicksave(9) --en faire l'antepenultienne version, celle a recuperer
save.Quickload(11) --reprendre la version au plus haut decimal possible
save.Quicksave(10) --la sauver en 10 -- donc la 10 sera l'avant derniere version
recentbest.Restore() --reprendre la toute derniere version pour continuer
end
----Stop module several steps to be saved--------------
----Start module print significant gains--------------
function GainAnother(g) --prints small gains
if g>relD2target then
--p("(gain en cours: ".. g..")")
p(i18.jet.gaining..g..")")
end
end
function forecastGain()
if JETgain>0 and comptetour>1 and comptetour<30 then
--local lncount=math.log (32-comptetour)
--local pentegain=JETgain/(JETgain-gainRecipe)-1 --increment relatif
--local espoirdegain=pentegain*lncount -- au pif: a fignoler !
local gainparminute=JETgain/JETtime
local tempsrestant=JETtime/comptetour*(32-comptetour)
local espoirdegain=gainparminute/0.479*0.00005*tempsrestant
--p("Temps restant: "..down(tempsrestant/60).." heures.".. "Peut encore gagner "..round(espoirdegain).." pts.")
p(i18.jet.timeleft..down(tempsrestant/60)..i18.jet.hours.. i18.jet.maygain..round(espoirdegain).." pts.")
end
end
----Stop module print significant gains--------------
function nettoyage()
--p("Nettoyage")
--p(i18.jet.cleaning)
selection.DeselectAll()
freeze.UnfreezeAll()
band.DeleteAll()
--p("Rtablissement de la structure secondaire")
--p(i18.jet.restorestructure)
save.LoadSecondaryStructure()
CI(1)
behavior.SetSlowFiltersDisabled(OriginalFilterSetting)
end
--Start Finale elegante pour laisser quelque chose d'evoluable
function elegantfinal()
--p("Enregistrement du meilleur rsultat")
p(i18.jet.savingbest)
recentbest.Restore()
if note1libre and comptetour>10 then
--p("Signature dans Note du segment 1")
p(i18.jet.signature)
structure.SetNote(1,historic)
end
save.Quicksave(3)
save.Quickload(9) -- ici, ne rien mettre dans la note1
nettoyage()
recentbest.Save()
--p("Enregistrement de solution voluable dans Undo ou Slot 9")
p(i18.jet.undosave)
save.Quickload(3)
WhriteNote() -- new 8/11/2014
nettoyage()
p(i18.jet.cleaning)
p(i18.jet.restorestructure)
end
--Stop fin de Finale elegante pour laisser quelque chose d'evoluable
----Start module error and cancel management ---------adapted from Jean-Bob, Ebola
function alreadydone()
if #saveNote1>0 and saveNote1:find(recipeName) then
--p(recipeName.." a dja te utilise.")
p(recipeName..i18.jet.alreadydone)
FirstJET=false
end
end
function testinterupt(gain)
if gain>20 and timeLeft> 96 then
if gain > 100* relD2target then
interuptor=true -- interrompt JET
TargetReset()
--p("Interruption de JET pour milieu de partie")
--p("Inutile d'insister avec JET maintenant")
--p("Je vous conseille de lancer Ebola")
p(i18.jet.middlegame)
p(i18.jet.stopnow)
p(i18.jet.suggestEbola)
end
elseif gain<0 then
interuptor=true -- interrompt JET
--p("Interruption de JET, perte anormale")
--p("Merci de signaler ce bug a l'auteur")
p(i18.jet.interrupt)
p(i18.jet.signalerror)
end
end
function DumpErr(err) -- Based on Jean-Bob
start,stop,line,msg=err:find(":(%d+):%s()")
err=err:sub(msg,#err)
p("---")
if err:find("Cancelled")~=nil then
--p("Arrt utilisateur.")
p(i18.recipe.de1)
else
--p("Erreur inattendue dtecte.")
--p("Ligne d'erreur : "..line)
--p("Message d'erreur : "..err)
p(i18.recipe.de2)
p(i18.recipe.de3..line)
p(i18.recipe.de4..err)
if note1libre then
--p("Sauvegarde de l'tat du script")
p(i18.recipe.lw4)
structure.SetNote(1,err)
end
end
elegantfinal()
end
----Stop module error and cancel management ---------
--Start filter management initialization -- New 01/09/2014
-- Reason: filters are some times important. I only check if they are slow before to desactivate
function iFilterSettings() -- new version 28/4/2015
print ("testing filter effect")
--save.Quicksave(23)
behavior.SetSlowFiltersDisabled(true)
local tempfilter=PROBABLEFILTER -- boolean, normally should be true here
local thisStartTime=os.time() -- en secondes?
--PROBABLEFILTER=true
--WiggleSimple()
--timeNeededFiltered=os.difftime(thisStartTime,os.time()) -- en sec
--save.Quickload(23)
--thisStartTime=os.time()
--PROBABLEFILTER=false
behavior.SetSlowFiltersDisabled(false)
--WiggleSimple()
--timeNeededNotFiltered=os.difftime(thisStartTime,os.time()) -- en sec
timeloss=os.difftime(os.time(),thisStartTime) -- en sec
--local timeloss=timeNeededFiltered-timeNeededNotFiltered
print ("Time loss by filtering: ",timeloss)
if timeloss<0.01 then
PROBABLEFILTER=false -- desactivate filter settings if filters are not altering time too much
else
PROBABLEFILTER=tempfilter
print ("Filters wil be disabled during wiggling")
end
behavior.SetSlowFiltersDisabled(OriginalFilterSetting)
--save.Quickload(23)
end
--Stop filter management initialization
--initializing in case of very start of the puzzle
function startingmenu()
if maxScore < TargetMean then
p("############################")
p("ENTREE")
if maxScore < 0 then
JET("Lucky LWS", LuckyLWS, 5, 4, 500)
JET("Total LWS", totalLws, 1, 7, 300)
end
if maxScore < 2000 then
JET("Lucky LWS", LuckyLWS, 5, 4, 300)
JET("Total LWS", totalLws, 1, 7, 200)
JET("Precise LWS", PreciseLWS, 5, 4, 100)
end
if maxScore < 8000 then JET("Total LWS", totalLws, 1, 7, 3) end
if maxScore < TargetMin then JET("Total LWS", totalLws, 1, 7, 1) end
JET("Total LWS", totalLws, 1, 7, 0.3)
end
end
--end section very start of the puzzle
-- starting the cooking menu
function cookingmenu()
p("############################")
p(i18.jet.maindishes)
JET("Total LWS", totalLws, 1, 7, 0.1)-- 1 a 7 segments
JET("WalkeR", WalkeR, 1, 7, 0.1) -- 1 a 7 segments
JET("Worm LWS", Worm,1,1,0.1) -- worm normal 26/02/2014
JET("Total LWS", totalLws, 3, 7, 0.1)
if segCnt > 13 then JET("Total LWS", totalLws, 8, 12, 0.1) end
JET("Total LWS", totalLws, 6, 7, 0.1)
if FirstJET and maxScore < TargetMin then -- sinon passer plus vite au dessert
JET("AcidTweeker", AcidTweeker, 1, 8, 1)
JET("Total LWS", totalLws, 4, 7, 0.1)
JET("Total LWS", totalLws, 2, 7, 0.1)
JET("Precise LWS", PreciseLWS, 5, 4, 0.01) -- 5 pires segments, 4 adjascents
JET("Total LWS", totalLws, 5, 7, 0.1)
JET("Lucky LWS", LuckyLWS, 5, 4, 0.01) -- 5 meilleurs segments, 4 adjascents
JET("Total LWS", totalLws, 1, 7, 0.01)
JET("Total LWS", totalLws, 3, 7, 0.01)
JET("AcidTweeker", AcidTweeker, 1, 8, 1)
end
if segCnt > 11 then JET("Total LWS", totalLws, 6, 10, 0.01) end
JET("Total LWS", totalLws, 4, 7, 0.01)
JET("WalkeR", WalkeR, 1, 7, 0.01)
JET("Worm LWS", Worm,1,1,0.01) -- worm normal 26/02/2014
JET("Total LWS", totalLws, 2, 7, 0.01)
JET("Total LWS", totalLws, 5, 7, 0.01)
if segCnt > 16 then
JET("Precise LWS", PreciseLWS, 9, 3, 0.01)
JET("Total LWS", totalLws, 8, 12, 0.01)
JET("Worm LWS", Worm,2,1,0.01) -- worm long 26/02/2014
end
if segCnt > 15 then JET("Lucky LWS", LuckyLWS, 5, 5, 0.1) end
JET("AcidTweeker", AcidTweeker, 1, 8, 3) -- le plus efficace, options 1.78
JET("WalkeR", WalkeR, 1, 7, 0.001)
if segCnt > 13 then JET("Total LWS", totalLws, 1, 12, 1) end
JET("Total LWS", totalLws, 1, 7, 0.01)
JET("AcidTweeker", AcidTweeker, 2, 6, 4) -- plus lent
end -- fin de cookingmenu
--Pour patienter jusqua la fin de la nuit
function dessert()
for i=1, 20 do -- NEW 20/6/2013, we rely on skipthis to avoid uneffective runnings
p("###############################")
p(i18.jet.runningdessert..i.."/20")
JET("SdHowMany", SdHowMany, 2, 4, 0)
JET("AcidTweeker", AcidTweeker, 3, 9, 3)
if segCnt > 13 then JET("Total LWS", totalLws, 1, 12, 1) end
JET("KrogWalkerV4", KrogWalkerV4, 1, 4, 0.0001)
JET("SdHowMany", SdHowMany, 26, 32, 0)
JET("AcidTweeker", AcidTweeker, 4, 8, 5)
JET("Total LWS", totalLws, 1, 7, 0.01)
if segCnt > 20 then JET("Precise LWS", PreciseLWS, 10, 4, 0.001) end
JET("Worm LWS", Worm,2,1,0) -- worm long 26/02/2014
if segCnt > 26 then JET("Total LWS", totalLws, 8, 25, 0.01) end
JET("M3wigglwSequence", M3wigglwSequence, 0, 10, 0.0001)
JET("walker_1point1_fn", walker_1point1_fn, 1, 13, 0.002)
JET("SdHowMany", SdHowMany, 5, 7, 0)
JET("Lucky LWS", LuckyLWS, 5, 4, 0.001)
JET("Power_Walker_fn", Power_Walker_fn, 1, 0, 0)
JET("Total LWS", totalLws, 1, 7, 0.001)
JET("AcidTweeker", AcidTweeker, 1, 8, 3)
JET("s_ws_wa_whatever", s_ws_wa_whatever, 0,0,0)
JET("WalkeR", WalkeR, 1, 7, 0.001)
JET("Total LWS", totalLws, 3, 7, 0.001)
JET("AcidTweeker", AcidTweeker, 4, 8, 5)
JET("MoonWalker", MoonWalker, 1, 7, 0.0001)
JET("Total LWS", totalLws, 3, 7, 0.001)
JET("Stabilize_fn", Stabilize_fn, 0,0,0)
JET("PiWalkerCamponV2", PiWalkerCamponV2, 3, 7, 0.001)
end
end
--fin du petit extra
OnlyDessert= false
function GetParams()
dlg = dialog.CreateDialog(recipeName)
dlg.OnlyDessert = dialog.AddCheckbox(i18.ask.options.OnlyDessert,OnlyDessert)
dlg.ok = dialog.AddButton("OK", 1)
dlg.cancel = dialog.AddButton(i18.ask.cancel, 0)
if dialog.Show(dlg) > 0 then
OnlyDessert=dlg.OnlyDessert.value
return true
else
print(i18.ask.logCancel)
return false
end
end
---M A I N ------------------------
function MAINjet()
checkbadpuzzle()
setlanguage()
multilingual(lang)
--SNIP de base ----
--p("Join Evolver Team 3.0 par BK")
p(i18.jet.intro1)
--p("Score de DEPART= ".. round(Score()))
p(i18.jet.intro2..round(Score()))
print("Bonus= "..round(filterB))
if GetParams() then
--p("1 nuit de travail PC. Bonne nuit " .. user.GetPlayerName() .."!")
p(i18.jet.intro3 .. user.GetPlayerName() .."!")
recentbest.Save() -- New BK 19/7/2013
Stanley()
note1free()
alreadydone()
if PROBABLEFILTER then iFilterSettings() end -- New 01/09/2014
if not OnlyDessert then
startingmenu()
cookingmenu()
end
dessert()
elegantfinal()
end
end
xpcall(MAINjet, DumpErr)
Comments
Bruno Kestemont Lv 1
Optional Only dessert