LibAcc: 0.8776=43/49, ProjAcc: 0.9167=33/36, Missing: 160
Module: src/world/components/story
function 𝓟1{$Lambda21} (𝓟2{one}: 𝓟[ty]241{Actor},𝓟3{two}: 𝓟[ty]241{Actor}): (𝓟4: 𝓛[ty]8666{Boolean})
{
return 𝓟4 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟2{one}.location,𝓟3{two}.location)
}
const 𝓟5{sameLocation}: [miss]𝓛[ty]8696{Function} = 𝓟1{$Lambda21};
function 𝓟6{$Lambda22} (𝓟7{one}: (𝓟[ty]103{Rule} ≠ 𝓟[ty]241{Actor}),𝓟8{two}: (𝓟[ty]103{Rule} ≠ 𝓟[ty]241{Actor})): (𝓟9: 𝓛[ty]8666{Boolean})
{
return 𝓟9 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟7{one}.name,𝓟8{two}.name)
}
const 𝓟10{sameName}: [miss]𝓛[ty]8696{Function} = 𝓟6{$Lambda22};
function 𝓟11{twoActors} (𝓟12{world}: 𝓟[ty]311{World},𝓟13{actor}: 𝓟[ty]241{Actor}): (𝓟14: 𝓛[ty]8670{Array})
{
const 𝓟15{actorOne}: 𝓟[ty]241{Actor} = 𝓛12546{BarBarToken}(𝓟13{actor},𝓟12{world}.actors.access(𝓛8746{Math}.floor(𝓛12548{AsteriskToken}(𝓛8746{Math}.random(),𝓟12{world}.actors.length))));
let 𝓟16{localActors}: 𝓛[ty]8670{Array};
if (𝓟15{actorOne}.location)
{
function 𝓟17{$Lambda23} (𝓟18{actor}): (𝓟19: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟19 = 𝓛12592{AmpersandAmpersandToken}(𝓟5{sameLocation}(𝓟18{actor},𝓟15{actorOne}),𝓛12569{ExclamationToken}(𝓟10{sameName}(𝓟18{actor},𝓟15{actorOne})))
}
𝓟16{localActors} ⟵ 𝓟12{world}.actors.filter(𝓟17{$Lambda23});
}
else
{
function 𝓟20{$Lambda24} (𝓟21{actor}): (𝓟22: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟22 = 𝓛12569{ExclamationToken}(𝓟10{sameName}(𝓟21{actor},𝓟15{actorOne}))
}
𝓟16{localActors} ⟵ 𝓟12{world}.actors.filter(𝓟20{$Lambda24});
}
if (𝓛12569{ExclamationToken}(𝓟16{localActors}.length))
{
return 𝓟14 = 𝓛8757{Array}(𝓟15{actorOne})
}
const 𝓟23{actorTwo}: 𝓟[ty]241{Actor} = 𝓟16{localActors}.access(𝓛8746{Math}.floor(𝓛12548{AsteriskToken}(𝓛8746{Math}.random(),𝓟16{localActors}.length)));
return 𝓟14 = 𝓛8757{Array}(𝓟15{actorOne},𝓟23{actorTwo})
}
function 𝓟24{checkMatch} (𝓟25{rule}: 𝓟[ty]103{Rule},𝓟26{source}: (𝓛[ty]10051{String} ≠ 𝓟[ty]241{Actor}),𝓟27{target}: [OOV]any,𝓟28{action}: [OOV]𝓟[ty]434{Event}): (𝓟29: (𝓟[ty]183{Type} ≠ 𝓛[ty]8666{Boolean}))
{
let 𝓟30{match};
const 𝓟31{sourceMatch}: [miss]𝓛[ty]8666{Boolean} = 𝓟227{ruleMatchesActor}(𝓟25{rule},𝓟26{source},𝓛8743{String});
const 𝓟32{targetMatch}: [miss]𝓛[ty]8666{Boolean} = 𝓟227{ruleMatchesActor}(𝓟25{rule},𝓟27{target},𝓛8743{String});
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟25{rule}.isDirectional),𝓛12612{ExclamationEqualsEqualsToken}(𝓟27{target},𝓛12643{undefined})))
{
const 𝓟33{flippedSourceMatch}: [miss]𝓛[ty]8666{Boolean} = 𝓟227{ruleMatchesActor}(𝓟25{rule},𝓟27{target},𝓛8743{String});
const 𝓟34{flippedTargetMatch}: [miss]𝓛[ty]8666{Boolean} = 𝓟227{ruleMatchesActor}(𝓟25{rule},𝓟26{source},𝓛8743{String});
𝓟30{match} ⟵ 𝓛12546{BarBarToken}(𝓛12592{AmpersandAmpersandToken}(𝓟31{sourceMatch},𝓟32{targetMatch}),𝓛12592{AmpersandAmpersandToken}(𝓟34{flippedTargetMatch},𝓟33{flippedSourceMatch}));
}
else
{
𝓟30{match} ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟31{sourceMatch},𝓟32{targetMatch});
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟28{action},𝓛12643{undefined}))
{
return 𝓟29 = 𝓛12592{AmpersandAmpersandToken}(𝓟30{match},𝓛12559{EqualsEqualsEqualsToken}(𝓟25{rule}.getActionType(),𝓟28{action}))
}
return 𝓟29 = 𝓟30{match}
}
function 𝓟35{matchRulesFor} (𝓟36{world}: 𝓟[ty]311{World},𝓟37{actorOne}: 𝓟[ty]241{Actor},𝓟38{actorTwo}: [OOV]any,𝓟39{action}: [OOV]𝓟[ty]434{Event}): (𝓟40: [OOV]any)
{
const 𝓟41{matchedRules}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
const 𝓟42{localRules}: [miss]𝓛[ty]8670{Array} = 𝓟81{getLocalRules}(𝓟36{world},𝓟37{actorOne});
{
let 𝓟43{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟43{i},𝓟42{localRules}.length))
{
{
const 𝓟44{currentRule}: [miss]𝓟[ty]103{Rule} = 𝓟42{localRules}.access(𝓟43{i});
const 𝓟45{isMatch}: [miss]𝓛[ty]8666{Boolean} = 𝓟24{checkMatch}(𝓟44{currentRule},𝓟37{actorOne},𝓟38{actorTwo},𝓟39{action});
if (𝓟45{isMatch})
{
𝓟41{matchedRules}.push(𝓟44{currentRule})
}
}
𝓛12556{POST_PlusPlusToken}(𝓟43{i})
}
}
if (𝓛12569{ExclamationToken}(𝓟41{matchedRules}.length))
{
return 𝓟40 = 𝓛8744{Boolean}
}
return 𝓟40 = 𝓟41{matchedRules}
}
function 𝓟46{randomMatch} (𝓟47{world}: 𝓟[ty]311{World},𝓟48{actorOne}: 𝓟[ty]241{Actor},𝓟49{actorTwo}: 𝓟[ty]241{Actor},𝓟50{exclude}: [OOV]any): (𝓟51: [OOV]any)
{
function 𝓟52{$Lambda25} (𝓟53{rule}): (𝓟54: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟54 = 𝓟232{checkTransitionMatch}(𝓟53{rule},𝓟48{actorOne})
}
const 𝓟55{transitions}: [miss]𝓛[ty]8670{Array} = 𝓟47{world}.rules.filter(𝓟52{$Lambda25});
const 𝓟56{interactions}: [miss]𝓛[ty]8670{Array} = 𝓛12546{BarBarToken}(𝓟35{matchRulesFor}(𝓟47{world},𝓟48{actorOne},𝓟49{actorTwo}),𝓛8757{Array}());
let 𝓟57{rules}: [miss]𝓛[ty]8670{Array} = 𝓟56{interactions}.concat(𝓟55{transitions});
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟50{exclude},𝓛12643{undefined}))
{
function 𝓟58{$Lambda26} (𝓟59{r}): (𝓟60: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟60 = 𝓛12612{ExclamationEqualsEqualsToken}(𝓟59{r}.id,𝓟50{exclude})
}
𝓟57{rules} ⟵ 𝓟57{rules}.filter(𝓟58{$Lambda26});
}
return 𝓟51 = (𝓟57{rules}.length ? 𝓟57{rules} : 𝓛8744{Boolean}
}
Module: src/world/components/time
function 𝓟61{advanceTime} (𝓟62{world}: 𝓟[ty]311{World}): (𝓟63: [miss]𝓛[ty]10033{Void})
{
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟62{world}.timedEvents.access(𝓟62{world}.timeIndex),𝓛12643{undefined}))
{
𝓟62{world}.renderEvent(𝓛8757{Array}(𝓟62{world}.timedEvents.access(𝓟62{world}.timeIndex)))
}
else
{
𝓟62{world}.randomEvent()
}
function 𝓟64{$Lambda27} (𝓟65{actor},𝓟66{idx}): (𝓟67: [miss]𝓛[ty]10033{Void})
{
if (𝓛12596{GreaterThanEqualsToken}(𝓟66{idx},𝓟62{world}.size))
{
}
const 𝓟68{age}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟62{world}.timeIndex,𝓟65{actor}.entryTime);
if (𝓛12595{GreaterThanToken}(𝓟68{age},𝓟65{actor}.lifeTime))
{
𝓟272{removeActor}(𝓟62{world},𝓟65{actor}.id)
}
}
𝓟62{world}.actors.forEach(𝓟64{$Lambda27})
𝓛12556{POST_PlusPlusToken}(𝓟62{world}.timeIndex)
}
Module: src/world/components/lib/getLocalRules
function 𝓟69{includes} (𝓟70{arr}: 𝓛[ty]8670{Array},𝓟71{item}: [OOV]any): (𝓟72: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟72 = 𝓛12612{ExclamationEqualsEqualsToken}(𝓟70{arr}.indexOf(𝓟71{item}),𝓛12616{MinusToken}(𝓛8745{Number}))
}
function 𝓟73{$Lambda30} (𝓟74{world}: 𝓟[ty]311{World},𝓟75{actor}: 𝓟[ty]241{Actor}): (𝓟76: 𝓛[ty]8670{Array})
{
function 𝓟77{$Lambda31} (𝓟78{rule}: 𝓟[ty]103{Rule}): (𝓟79: [miss]𝓛[ty]8666{Boolean})
{
const 𝓟80{isLocalized}: 𝓛[ty]8666{Boolean} = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟78{rule}.locations.length));
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟80{isLocalized}),𝓛12569{ExclamationToken}(𝓟75{actor}.location)))
{
return 𝓟79 = 𝓛8744{Boolean}
}
return 𝓟79 = 𝓟69{includes}(𝓟78{rule}.locations,𝓟75{actor}.location)
}
return 𝓟76 = 𝓟74{world}.rules.filter(𝓟77{$Lambda31})
}
const 𝓟81{getLocalRules}: [miss]𝓛[ty]8696{Function} = 𝓟73{$Lambda30};
Module: src/main
Module: src/world/components/events
type 𝓟[ty]121{StoryEvent} = any
function 𝓟122{$Lambda17} (𝓟123{arr}: 𝓛[ty]8670{Array}): (𝓟124: [OOV]any)
{
return 𝓟124 = 𝓟123{arr}.access(𝓛8746{Math}.floor(𝓛12548{AsteriskToken}(𝓛8746{Math}.random(),𝓟123{arr}.length)))
}
const 𝓟125{selectAtRandom}: [miss]𝓛[ty]8696{Function} = 𝓟122{$Lambda17};
function 𝓟126{populateTemplate} (𝓟127{eventTemplate},𝓟128{actorOne}: 𝓟[ty]241{Actor},𝓟129{actorTwo}: 𝓟[ty]241{Actor}): (𝓟130: [OOV]any)
{
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟127{eventTemplate}),𝓛12569{ExclamationToken}(𝓟127{eventTemplate}.length)))
{
return 𝓟130 = 𝓛8744{Boolean}
}
function 𝓟131{$Lambda18} (𝓟132{value}): (𝓟133: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟132{value},𝓟442{SOURCE}))
{
return 𝓟133 = 𝓟128{actorOne}.id
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟132{value},𝓟441{TARGET}),𝓟129{actorTwo}))
{
return 𝓟133 = 𝓟129{actorTwo}.id
}
else
{
return 𝓟133 = 𝓟132{value}
}
}
}
return 𝓟130 = 𝓟127{eventTemplate}.map(𝓟131{$Lambda18})
}
function 𝓟134{renderTemplate} (𝓟135{world}: 𝓟[ty]311{World},𝓟136{template}: 𝓛[ty]8670{Array}): (𝓟137: [OOV]any)
{
function 𝓟138{$Lambda19} (𝓟139{piece}): (𝓟140: [miss]𝓛[ty]10051{String})
{
return 𝓟140 = 𝓟289{fetchElement}(𝓟135{world},𝓟139{piece})
}
const 𝓟141{result}: [miss]𝓛[ty]8670{Array} = 𝓟136{template}.map(𝓟138{$Lambda19});
const 𝓟142{body}: [miss]𝓛[ty]10051{String} = 𝓟141{result}.join(𝓛8743{String});
if (𝓛12569{ExclamationToken}(𝓟142{body}.length))
{
return 𝓟137 = 𝓛8743{String}
}
return 𝓟137 = 𝓟443{addPeriod}(𝓟444{capitalizeFirst}(𝓟142{body}))
}
function 𝓟143{addConsequentActor} (𝓟144{world}: 𝓟[ty]311{World},𝓟145{rule}: 𝓟[ty]103{Rule},𝓟146{actorOne},𝓟147{actorTwo}): (𝓟148: [miss]𝓛[ty]10033{Void})
{
const 𝓟149{consequentActor}: [miss]𝓟[ty]241{Actor} = 𝓟233{CONSTRUCTOR}(𝓟145{rule}.consequentActor,𝓟144{world},𝓟146{actorOne},𝓟147{actorTwo});
𝓟149{consequentActor}.parentId ⟵ 𝓟145{rule}.id;
𝓟144{world}.addActor(𝓟149{consequentActor})
}
function 𝓟150{applyConsequent} (𝓟151{world}: 𝓟[ty]311{World},𝓟152{typeExpression}): (𝓟153: [OOV]any)
{
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟152{typeExpression}.length),𝓛12559{EqualsEqualsEqualsToken}(𝓟152{typeExpression}.access(𝓛8745{Number}),𝓛12643{undefined})))
{
return 𝓟153 = 𝓛8744{Boolean}
}
const 𝓟154{typeExpressionArray} = (𝓛8757{Array}.isArray(𝓟152{typeExpression}.access(𝓛8745{Number})) ? 𝓟152{typeExpression} : 𝓛8757{Array}(𝓟152{typeExpression});
let 𝓟155{result}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟156{$Lambda20} (𝓟157{expr}: [OOV]𝓟[ty]121{StoryEvent}): (𝓟158: [miss]𝓛[ty]10033{Void})
{
𝓛12577{$Switch}(𝓟157{expr}.access(𝓛8745{Number}))
𝓛12634{$Case}(𝓟438{VANISH})
{
const 𝓟159{actor}: [miss]𝓛[ty]8655{Number} = 𝓟157{expr}.access(𝓛8745{Number});
𝓟272{removeActor}(𝓟151{world},𝓟159{actor})
}
𝓛12634{$Case}(𝓟436{MOVE_OUT})
𝓛12634{$Case}(𝓟435{MOVE_IN})
{
const 𝓟160{actor} = 𝓟151{world}.getActorById(𝓟157{expr}.access(𝓛8745{Number}));
if (𝓟160{actor})
{
𝓟160{actor}.location ⟵ 𝓟157{expr}.access(𝓛8745{Number});
}
}
{
const 𝓟161{source} = 𝓟285{getActor}(𝓟151{world},𝓟157{expr}.access(𝓛8745{Number}));
const 𝓟162{target} = 𝓟285{getActor}(𝓟151{world},𝓟157{expr}.access(𝓛8745{Number}));
const 𝓟163{rules} = 𝓟35{matchRulesFor}(𝓟151{world},𝓟161{source},𝓟162{target},𝓟157{expr}.access(𝓛8745{Number}));
if (𝓛12592{AmpersandAmpersandToken}(𝓟163{rules},𝓟163{rules}.length))
{
const 𝓟164{rule} = 𝓟125{selectAtRandom}(𝓟163{rules});
𝓟155{result} ⟵ 𝓟165{processEvent}(𝓟151{world},𝓟164{rule},𝓟161{source},𝓟162{target});
}
}
}
𝓟154{typeExpressionArray}.forEach(𝓟156{$Lambda20})
return 𝓟153 = 𝓟155{result}
}
function 𝓟165{processEvent} (𝓟166{world}: 𝓟[ty]311{World},𝓟167{rule}: 𝓟[ty]103{Rule},𝓟168{actorOne}: 𝓟[ty]241{Actor},𝓟169{actorTwo}: 𝓟[ty]241{Actor}): (𝓟170: [OOV]any)
{
const 𝓟171{causeTemplate} = 𝓟126{populateTemplate}(𝓟167{rule}.cause.template,𝓟168{actorOne},𝓟169{actorTwo});
let 𝓟172{consequentTemplate}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
let 𝓟173{tertiaryTemplate}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
if (𝓟167{rule}.consequent)
{
𝓟172{consequentTemplate} ⟵ 𝓟126{populateTemplate}(𝓟167{rule}.consequent.template,𝓟168{actorOne},𝓟169{actorTwo});
𝓟173{tertiaryTemplate} ⟵ 𝓟126{populateTemplate}(𝓟167{rule}.consequent.type,𝓟168{actorOne},𝓟169{actorTwo});
}
const 𝓟174{causeText} = (𝓟171{causeTemplate} ? 𝓟134{renderTemplate}(𝓟166{world},𝓟171{causeTemplate}) : 𝓛8743{String};
const 𝓟175{consequentText} = (𝓟172{consequentTemplate} ? 𝓟134{renderTemplate}(𝓟166{world},𝓟172{consequentTemplate}) : 𝓛8743{String};
const 𝓟176{tertiary} = (𝓟173{tertiaryTemplate} ? 𝓟150{applyConsequent}(𝓟166{world},𝓟173{tertiaryTemplate}) : 𝓛8743{String};
if (𝓟167{rule}.consequentActor)
{
𝓟143{addConsequentActor}(𝓟166{world},𝓟167{rule},𝓟168{actorOne},𝓟169{actorTwo})
}
if (𝓟167{rule}.mutations)
{
𝓟167{rule}.mutations(𝓟168{actorOne},𝓟169{actorTwo})
}
const 𝓟177{result} = 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟174{causeText},𝓟175{consequentText}),𝓟176{tertiary});
return 𝓟170 = 𝓟177{result}
}
Module: src/components/type
function 𝓟178{CONSTRUCTOR} (𝓟179{types}: [OOV]any): (𝓟[ty]183{Type})
{
const 𝓟[ty]183{Type};
const 𝓟[ty]183{Type};
𝓟[ty]183{Type}.types ⟵ (𝓛8757{Array}.isArray(𝓟179{types}) ? 𝓟179{types} : 𝓛8757{Array}(𝓟179{types});
}
class 𝓟[ty]183{Type}{
𝓟185{types}: 𝓛[ty]8670{Array};
function 𝓟194{replace} (𝓟195{oldType},𝓟196{newType}): (𝓟197: [miss]𝓛[ty]10033{Void})
{
const 𝓟198{index}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]183{Type}.types.indexOf(𝓟195{oldType});
if (𝓛1{<UNKNOWN>}(𝓟198{index},𝓛8745{Number}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟195{oldType},𝓟195{oldType}))
}
𝓟[ty]183{Type}.types.access(𝓟198{index}) ⟵ 𝓟196{newType};
}
function 𝓟186{extend} (𝓟187{type}: [OOV]any): (𝓟188: [miss]𝓟[ty]183{Type})
{
const 𝓟189{newType}: [miss]𝓛[ty]8670{Array} = (𝓛1{<UNKNOWN>}(𝓟187{type},𝓛12643{undefined}) ? 𝓟187{type}.get() : 𝓛8757{Array}(𝓟187{type});
const 𝓟190{currentTypes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]183{Type}.get();
const 𝓟191{nextTypes}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛12587{$Spread}(𝓟190{currentTypes}),𝓛12587{$Spread}(𝓟189{newType}));
return 𝓟188 = 𝓟178{CONSTRUCTOR}(𝓟191{nextTypes})
}
function 𝓟202{remove} (𝓟203{type}): (𝓟204: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]183{Type}.types.splice(𝓟[ty]183{Type}.types.indexOf(𝓟203{type}),𝓛8745{Number})
}
function 𝓟192{get} (): (𝓟193: [miss]𝓛[ty]8670{Array})
{
return 𝓟193 = 𝓟[ty]183{Type}.types.slice()
}
function 𝓟199{add} (𝓟200{type}): (𝓟201: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]183{Type}.types.push(𝓟200{type})
}
}
Module: src/world/components/lib/ruleMatchesActor
type 𝓟[ty]205{Position} = any
function 𝓟206{$Lambda32} (𝓟207{set}: 𝓛[ty]8670{Array},𝓟208{item}: [OOV]any): (𝓟209: 𝓛[ty]8666{Boolean})
{
{
let 𝓟210{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟210{i},𝓟207{set}.length))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟207{set}.access(𝓟210{i}),𝓟208{item}))
{
return 𝓟209 = 𝓛8744{Boolean}
}
}
𝓛12556{POST_PlusPlusToken}(𝓟210{i})
}
}
return 𝓟209 = 𝓛8744{Boolean}
}
const 𝓟211{includes}: [miss]𝓛[ty]8696{Function} = 𝓟206{$Lambda32};
function 𝓟212{$Lambda33} (𝓟213{set},𝓟214{valueOrSet}): (𝓟215: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓛8757{Array}.isArray(𝓟214{valueOrSet})))
{
return 𝓟215 = 𝓟211{includes}(𝓟213{set},𝓟214{valueOrSet})
}
function 𝓟216{$Lambda34} (𝓟217{acc},𝓟218{curr}): (𝓟219: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟219 = 𝓛12592{AmpersandAmpersandToken}(𝓟217{acc},𝓟211{includes}(𝓟214{valueOrSet},𝓟218{curr}))
}
return 𝓟215 = 𝓟213{set}.reduce(𝓟216{$Lambda34},𝓛8744{Boolean})
}
const 𝓟220{isSubset}: [miss]𝓛[ty]8696{Function} = 𝓟212{$Lambda33};
function 𝓟221{$Lambda35} (𝓟222{rule}: 𝓟[ty]103{Rule},𝓟223{actor}: [OOV]any,𝓟224{position}: [OOV]𝓟[ty]205{Position}): (𝓟225: 𝓛[ty]8666{Boolean})
{
let 𝓟226{ruleToken}: [OOV]𝓛[ty]2{<UNKNOWN>} = (𝓛12559{EqualsEqualsEqualsToken}(𝓟224{position},𝓛8743{String}) ? 𝓟222{rule}.getSource() : 𝓟222{rule}.getTarget();
if (𝓛12569{ExclamationToken}(𝓟223{actor}))
{
return 𝓟225 = 𝓛12569{ExclamationToken}(𝓟226{ruleToken})
}
else
{
return 𝓟225 = (𝓛1{<UNKNOWN>}(𝓟226{ruleToken},𝓛12643{undefined}) ? 𝓟220{isSubset}(𝓟226{ruleToken}.get(),𝓟223{actor}.getTypes()) : 𝓛12559{EqualsEqualsEqualsToken}(𝓟226{ruleToken},𝓟223{actor}.id)
}
}
const 𝓟227{ruleMatchesActor}: [miss]𝓛[ty]8696{Function} = 𝓟221{$Lambda35};
Module: src/components/actor
function 𝓟233{CONSTRUCTOR} (𝓟234{data},𝓟235{world},𝓟236{actorOne}: 𝓟[ty]241{Actor},𝓟237{actorTwo}: 𝓟[ty]241{Actor}): (𝓟[ty]241{Actor})
{
const 𝓟[ty]241{Actor};
const 𝓟[ty]241{Actor};
𝓟[ty]241{Actor}.type ⟵ 𝓟234{data}.type;
𝓟[ty]241{Actor}.name ⟵ 𝓟234{data}.name;
𝓟[ty]241{Actor}.members ⟵ 𝓛8757{Array}();
if (𝓟234{data}.locations)
{
𝓟[ty]241{Actor}.location ⟵ 𝓛12546{BarBarToken}(𝓟234{data}.location,𝓟234{data}.locations.access(𝓛8745{Number}));
𝓟[ty]241{Actor}.locations ⟵ 𝓟234{data}.locations;
}
else
{
𝓟[ty]241{Actor}.locations ⟵ 𝓛8757{Array}();
𝓟[ty]241{Actor}.location ⟵ 𝓛12643{undefined};
}
𝓟[ty]241{Actor}.lifeTime ⟵ 𝓛12546{BarBarToken}(𝓟234{data}.lifeTime,𝓛8745{Number});
if (𝓟234{data}.members)
{
𝓟[ty]241{Actor}.fetchMembers(𝓟235{world},𝓟234{data}.members,𝓟237{actorTwo},𝓟237{actorTwo})
}
if (𝓟234{data}.initializeName)
{
𝓟[ty]241{Actor}.name ⟵ 𝓟234{data}.initializeName(𝓟[ty]241{Actor},𝓟235{world});
}
}
class 𝓟[ty]241{Actor}{
𝓟243{locations}: 𝓛[ty]8670{Array};
𝓟244{name}: 𝓛[ty]10051{String};
𝓟245{location}: [OOV]any;
𝓟246{entryTime}: 𝓛[ty]8655{Number};
𝓟247{lifeTime}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8655{Number});
𝓟248{id}: 𝓛[ty]8655{Number};
𝓟249{members}: 𝓛[ty]8670{Array};
𝓟250{type}: 𝓟[ty]183{Type};
𝓟251{parentId}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
function 𝓟252{fetchMembers} (𝓟253{world},𝓟254{members},𝓟255{actorOne},𝓟256{actorTwo}): (𝓟257: [miss]𝓛[ty]10033{Void})
{
function 𝓟258{$Lambda0} (𝓟259{member},𝓟260{idx}): (𝓟261: [miss]𝓛[ty]10033{Void})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟259{member},𝓟442{SOURCE}))
{
𝓟[ty]241{Actor}.members.access(𝓟260{idx}) ⟵ 𝓟255{actorOne};
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟259{member},𝓟441{TARGET}))
{
𝓟[ty]241{Actor}.members.access(𝓟260{idx}) ⟵ 𝓟256{actorTwo};
}
}
}
𝓟254{members}.forEach(𝓟258{$Lambda0})
}
function 𝓟262{hasMember} (𝓟263{id}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟264: 𝓛[ty]8666{Boolean})
{
let 𝓟265{found}: 𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
{
let 𝓟266{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟266{i},𝓟[ty]241{Actor}.members.length))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]241{Actor}.members.access(𝓟266{i}).id,𝓟263{id}))
{
𝓟265{found} ⟵ 𝓛8744{Boolean};
}
}
𝓛12556{POST_PlusPlusToken}(𝓟266{i})
}
}
return 𝓟264 = 𝓟265{found}
}
function 𝓟267{getTypes} (): (𝓟268: [miss]𝓛[ty]8670{Array})
{
return 𝓟268 = 𝓟[ty]241{Actor}.type.get()
}
function 𝓟269{setEntryTime} (𝓟270{time}): (𝓟271: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]241{Actor}.entryTime ⟵ 𝓟270{time};
}
}
Module: src/world/components/utility
function 𝓟272{removeActor} (𝓟273{world}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟274{id}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟275: [miss]𝓛[ty]10033{Void})
{
let 𝓟276{index}: [OOV]any = 𝓛12643{undefined};
{
let 𝓟277{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟277{i},𝓟273{world}.actors.length))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟273{world}.actors.access(𝓟277{i}).id,𝓟274{id}))
{
𝓟276{index} ⟵ 𝓟277{i};
}
}
𝓛12556{POST_PlusPlusToken}(𝓟277{i})
}
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟276{index},𝓛12643{undefined}))
{
𝓟273{world}.actors.splice(𝓟276{index},𝓛8745{Number})
𝓛12614{POST_MinusMinusToken}(𝓟273{world}.size)
}
}
function 𝓟278{getLocalSet} (𝓟279{world}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟280{location}): (𝓟281: [OOV]any)
{
function 𝓟282{$Lambda28} (𝓟283{actor}): (𝓟284: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟284 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟283{actor}.location,𝓟280{location}.name)
}
return 𝓟281 = 𝓟279{world}.actors.filter(𝓟282{$Lambda28})
}
function 𝓟285{getActor} (𝓟286{world}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟287{reference}: [OOV]any): (𝓟288: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟287{reference},𝓛12643{undefined}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟287{reference}),𝓛8743{String}))
{
return 𝓟288 = 𝓟286{world}.getActorById(𝓟287{reference})
}
return 𝓟288 = 𝓛8744{Boolean}
}
function 𝓟289{fetchElement} (𝓟290{world}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟291{element}: [OOV]any): (𝓟292: 𝓛[ty]10051{String})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟291{element}),𝓛8743{String}))
{
const 𝓟293{actor} = 𝓟285{getActor}(𝓟290{world},𝓟291{element});
if (𝓟293{actor})
{
return 𝓟292 = 𝓟293{actor}.name
}
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟291{element}),𝓛8743{String}))
{
return 𝓟292 = 𝓟291{element}
}
}
return 𝓟292 = 𝓛8743{String}
}
Module: src/world/world
function 𝓟294{$Lambda1} (𝓟295{arr}: 𝓛[ty]8670{Array}): (𝓟296: [miss]𝓛[ty]8670{Array})
{
let 𝓟297{box}: [miss]𝓛[ty]8642{Object} = {};
function 𝓟298{$Lambda2} (𝓟299{item}): (𝓟300: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟300 = 𝓛1{<UNKNOWN>}(𝓟297{box}.access(𝓟299{item}),𝓛8744{Boolean})
}
𝓟295{arr}.forEach(𝓟298{$Lambda2})
return 𝓟296 = 𝓛8741{Object}.keys(𝓟297{box})
}
const 𝓟301{unique}: [miss]𝓛[ty]8696{Function} = 𝓟294{$Lambda1};
function 𝓟302{$Lambda3} (𝓟303{arr}: 𝓛[ty]8670{Array}): (𝓟304: [OOV]any)
{
return 𝓟304 = 𝓟303{arr}.access(𝓛8746{Math}.floor(𝓛12548{AsteriskToken}(𝓛8746{Math}.random(),𝓟303{arr}.length)))
}
const 𝓟305{selectAtRandom}: [miss]𝓛[ty]8696{Function} = 𝓟302{$Lambda3};
function 𝓟306{CONSTRUCTOR} (𝓟307{options}): (𝓟[ty]311{World})
{
const 𝓟[ty]311{World};
const 𝓟[ty]311{World};
𝓟[ty]311{World}.size ⟵ 𝓛8745{Number};
𝓟[ty]311{World}.lastId ⟵ 𝓛12616{MinusToken}(𝓛8745{Number});
𝓟[ty]311{World}.actors ⟵ 𝓛8757{Array}();
𝓟[ty]311{World}.numLocations ⟵ 𝓛8745{Number};
𝓟[ty]311{World}.locations ⟵ 𝓛8757{Array}();
𝓟[ty]311{World}.numRules ⟵ 𝓛8745{Number};
𝓟[ty]311{World}.rules ⟵ 𝓛8757{Array}();
𝓟[ty]311{World}.logEvents ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟307{options},𝓟307{options}.logEvents);
𝓟[ty]311{World}.excludePrevious ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟307{options},𝓟307{options}.excludePrevious);
𝓟[ty]311{World}.previousMatch ⟵ 𝓛12643{undefined};
𝓟[ty]311{World}.timeIndex ⟵ 𝓛8745{Number};
𝓟[ty]311{World}.timedEvents ⟵ {};
𝓟[ty]311{World}.output ⟵ 𝓛8743{String};
}
class 𝓟[ty]311{World}{
𝓟313{locations}: 𝓛[ty]8670{Array};
𝓟314{numRules}: 𝓛[ty]8655{Number};
𝓟315{size}: 𝓛[ty]8655{Number};
𝓟316{timedEvents}: [OOV]any;
𝓟317{timeIndex}: 𝓛[ty]8655{Number};
𝓟318{numLocations}: 𝓛[ty]8655{Number};
𝓟319{excludePrevious}: 𝓛[ty]8666{Boolean};
𝓟320{previousMatch}: [OOV]any;
𝓟321{actors}: 𝓛[ty]8670{Array};
𝓟322{lastId}: 𝓛[ty]8655{Number};
𝓟323{logEvents}: 𝓛[ty]8666{Boolean};
𝓟324{rules}: 𝓛[ty]8670{Array};
𝓟325{output}: 𝓛[ty]10051{String};
function 𝓟381{registerTimedEvents} (𝓟382{theEvents}): (𝓟383: [miss]𝓛[ty]10033{Void})
{
function 𝓟384{$Lambda7} (𝓟385{event}): (𝓟386: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]311{World}.timedEvents.access(𝓟385{event}.step) ⟵ 𝓟385{event}.event;
}
𝓟382{theEvents}.forEach(𝓟384{$Lambda7})
}
function 𝓟345{getLocationByName} (𝓟346{name}): (𝓟347: [OOV]any)
{
{
let 𝓟348{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟348{i},𝓟[ty]311{World}.locations.length))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]311{World}.locations.access(𝓟348{i}).name,𝓟346{name}))
{
return 𝓟347 = 𝓟[ty]311{World}.locations.access(𝓟348{i}).id
}
}
𝓛12556{POST_PlusPlusToken}(𝓟348{i})
}
}
return 𝓟347 = 𝓛8744{Boolean}
}
function 𝓟353{getActorById} (𝓟354{id}): (𝓟355: [OOV]any)
{
{
let 𝓟356{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟356{i},𝓟[ty]311{World}.size))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]311{World}.actors.access(𝓟356{i}).id,𝓟354{id}))
{
return 𝓟355 = 𝓟[ty]311{World}.actors.access(𝓟356{i})
}
}
𝓛12556{POST_PlusPlusToken}(𝓟356{i})
}
}
return 𝓟355 = 𝓛8744{Boolean}
}
function 𝓟333{addActor} (𝓟334{actor}: [OOV]any): (𝓟335: [OOV]any)
{
function 𝓟336{$Lambda4} (𝓟337{actorToAdd}: 𝓟[ty]241{Actor}): (𝓟338: [miss]𝓛[ty]8655{Number})
{
const 𝓟339{id}: [miss]𝓛[ty]8655{Number} = 𝓛12641{PlusToken}(𝓟[ty]311{World}.lastId,𝓛8745{Number});
𝓟[ty]311{World}.lastId ⟵ 𝓟339{id};
𝓟337{actorToAdd}.id ⟵ 𝓟339{id};
𝓟337{actorToAdd}.setEntryTime(𝓟[ty]311{World}.timeIndex)
𝓟[ty]311{World}.actors.push(𝓟337{actorToAdd})
𝓛12556{POST_PlusPlusToken}(𝓟[ty]311{World}.size)
return 𝓟338 = 𝓟339{id}
}
const 𝓟340{add}: [miss]𝓛[ty]8696{Function} = 𝓟336{$Lambda4};
if (𝓛8757{Array}.isArray(𝓟334{actor}))
{
function 𝓟341{$Lambda5} (𝓟342{item}): (𝓟343: [OOV]any)
{
return 𝓟343 = 𝓟340{add}.apply(𝓟[ty]311{World},𝓛8757{Array}(𝓟342{item}))
}
𝓟334{actor}.forEach(𝓟341{$Lambda5})
return 𝓟335 = 𝓛8744{Boolean}
}
const 𝓟344{id} = 𝓟340{add}.apply(𝓟[ty]311{World},𝓛8757{Array}(𝓟334{actor}));
return 𝓟335 = 𝓟344{id}
}
function 𝓟387{findRule} (𝓟388{piece}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟389: [OOV]any)
{
const 𝓟390{source} = 𝓟285{getActor}(𝓟[ty]311{World},𝓟388{piece}.access(𝓛8745{Number}));
const 𝓟391{action}: [miss]𝓛[ty]11364{Event} = 𝓟388{piece}.access(𝓛8745{Number});
const 𝓟392{target} = 𝓟285{getActor}(𝓟[ty]311{World},𝓟388{piece}.access(𝓛8745{Number}));
if (𝓛12592{AmpersandAmpersandToken}(𝓟390{source},𝓟392{target}))
{
{
let 𝓟393{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟393{i},𝓟[ty]311{World}.numRules))
{
{
const 𝓟394{rule}: [miss]𝓟[ty]103{Rule} = 𝓟[ty]311{World}.rules.access(𝓟393{i});
if (𝓟24{checkMatch}(𝓟394{rule},𝓟390{source},𝓟392{target},𝓟391{action}))
{
return 𝓟389 = 𝓛8757{Array}(𝓟394{rule},𝓟390{source},𝓟392{target})
}
}
𝓛12556{POST_PlusPlusToken}(𝓟393{i})
}
}
}
return 𝓟389 = 𝓛8744{Boolean}
}
function 𝓟349{getLocationById} (𝓟350{id}): (𝓟351: [OOV]any)
{
{
let 𝓟352{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟352{i},𝓟[ty]311{World}.locations.length))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]311{World}.locations.access(𝓟352{i}).id,𝓟350{id}))
{
return 𝓟351 = 𝓟[ty]311{World}.locations.access(𝓟352{i})
}
}
𝓛12556{POST_PlusPlusToken}(𝓟352{i})
}
}
return 𝓟351 = 𝓛8744{Boolean}
}
function 𝓟377{runStory} (𝓟378{steps},𝓟379{theEvents}): (𝓟380: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]311{World}.registerTimedEvents(𝓟379{theEvents})
while (𝓛1{<UNKNOWN>}(𝓟[ty]311{World}.timeIndex,𝓟378{steps}))
{
𝓟61{advanceTime}(𝓟[ty]311{World})
}
}
function 𝓟330{addLocation} (𝓟331{data}): (𝓟332: [miss]𝓛[ty]10033{Void})
{
𝓟331{data}.id ⟵ 𝓟[ty]311{World}.numLocations;
𝓟[ty]311{World}.locations.push(𝓟82{CONSTRUCTOR}(𝓟331{data}))
𝓛12556{POST_PlusPlusToken}(𝓟[ty]311{World}.numLocations)
}
function 𝓟326{addRule} (𝓟327{data}): (𝓟328: [miss]𝓛[ty]8655{Number})
{
const 𝓟329{id}: [miss]𝓛[ty]8655{Number} = 𝓛12556{POST_PlusPlusToken}(𝓟[ty]311{World}.numRules);
𝓟[ty]311{World}.rules.push(𝓟97{CONSTRUCTOR}(𝓟327{data},𝓟329{id}))
return 𝓟328 = 𝓟329{id}
}
function 𝓟368{randomEvent} (): (𝓟369: [miss]𝓛[ty]10033{Void})
{
let 𝓟370{output}: 𝓛[ty]10051{String} = 𝓛8743{String};
let 𝓟371{count}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟372{rules}: [OOV]any = 𝓛8744{Boolean};
let 𝓟373{actorOne};
let 𝓟374{actorTwo};
while (𝓛12592{AmpersandAmpersandToken}(𝓛1{<UNKNOWN>}(𝓟371{count},𝓛8745{Number}),𝓛12569{ExclamationToken}(𝓟372{rules})))
{
𝓛8757{Array}(𝓟373{actorOne},𝓟374{actorTwo}) ⟵ 𝓟11{twoActors}(𝓟[ty]311{World});
const 𝓟375{exclude}: [miss]𝓛[ty]8655{Number} = (𝓟[ty]311{World}.excludePrevious ? 𝓟[ty]311{World}.previousMatch : 𝓛12643{undefined};
𝓟372{rules} ⟵ 𝓟46{randomMatch}(𝓟[ty]311{World},𝓟373{actorOne},𝓟374{actorTwo},𝓟375{exclude});
𝓛12556{POST_PlusPlusToken}(𝓟371{count})
}
if (𝓛12569{ExclamationToken}(𝓟372{rules}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
const 𝓟376{rule} = 𝓟305{selectAtRandom}(𝓟372{rules});
𝓟[ty]311{World}.previousMatch ⟵ 𝓟376{rule}.id;
if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]311{World}.logEvents,𝓟376{rule}.name))
{
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟376{rule}.name))
}
𝓛12564{FirstCompoundAssignment}(𝓟370{output},𝓟165{processEvent}(𝓟[ty]311{World},𝓟376{rule},𝓟373{actorOne},𝓟374{actorTwo}))
𝓟[ty]311{World}.output ⟵ 𝓛12607{$Template}(𝓟[ty]311{World}.output,𝓟370{output});
}
function 𝓟395{testMatches} (): (𝓟396: [miss]𝓛[ty]8642{Object})
{
const 𝓟397{results}: [miss]𝓛[ty]8642{Object} = {};
function 𝓟398{$Lambda8} (𝓟399{actor}): (𝓟400: [miss]𝓛[ty]10033{Void})
{
𝓟397{results}.access(𝓟399{actor}.name) ⟵ {};
if (𝓟399{actor}.locations.length)
{
𝓛1{<UNKNOWN>}(𝓟399{actor}.locations)
function 𝓟401{$Lambda9} (𝓟402{location}): (𝓟403: [miss]𝓛[ty]10033{Void})
{
𝓟399{actor}.location ⟵ 𝓟402{location};
𝓟[ty]311{World}.populateMatchesForActor(𝓟399{actor},𝓟397{results})
}
𝓟399{actor}.locations.forEach(𝓟401{$Lambda9})
}
𝓟[ty]311{World}.populateMatchesForActor(𝓟399{actor},𝓟397{results})
}
𝓟[ty]311{World}.actors.forEach(𝓟398{$Lambda8})
return 𝓟396 = 𝓟397{results}
}
function 𝓟357{renderEvent} (𝓟358{events}): (𝓟359: [miss]𝓛[ty]10033{Void})
{
let 𝓟360{output}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟361{$Lambda6} (𝓟362{storyEvent}): (𝓟363: [miss]𝓛[ty]10033{Void})
{
const 𝓟364{results} = 𝓟[ty]311{World}.findRule(𝓟362{storyEvent});
if (𝓟364{results})
{
const 𝓟365{rule}: [miss]𝓟[ty]103{Rule} = 𝓛12589{$ArrayAccess}(𝓟364{results});
const 𝓟366{actorOne}: [miss]𝓟[ty]241{Actor} = 𝓛12589{$ArrayAccess}(𝓟364{results});
const 𝓟367{actorTwo}: [miss]𝓟[ty]241{Actor} = 𝓛12589{$ArrayAccess}(𝓟364{results});
𝓛12564{FirstCompoundAssignment}(𝓟360{output},𝓟165{processEvent}(𝓟[ty]311{World},𝓟365{rule},𝓟366{actorOne},𝓟367{actorTwo}))
}
}
𝓛1{<UNKNOWN>}(𝓟361{$Lambda6})
𝓟[ty]311{World}.output ⟵ 𝓛12607{$Template}(𝓟[ty]311{World}.output,𝓟360{output});
}
function 𝓟404{populateMatchesForActor} (𝓟405{actor},𝓟406{results}): (𝓟407: [miss]𝓛[ty]10033{Void})
{
let 𝓟408{localActors};
if (𝓟405{actor}.location)
{
function 𝓟409{$Lambda10} (𝓟410{actorTwo}): (𝓟411: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟411 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟405{actor}.location,𝓟410{actorTwo}.location),𝓛12612{ExclamationEqualsEqualsToken}(𝓟405{actor}.name,𝓟410{actorTwo}.name))
}
𝓟408{localActors} ⟵ 𝓟[ty]311{World}.actors.filter(𝓟409{$Lambda10});
}
else
{
function 𝓟412{$Lambda11} (𝓟413{actorTwo}): (𝓟414: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟414 = 𝓛12612{ExclamationEqualsEqualsToken}(𝓟413{actorTwo}.name,𝓟405{actor}.name)
}
𝓟408{localActors} ⟵ 𝓟[ty]311{World}.actors.filter(𝓟412{$Lambda11});
}
let 𝓟415{localRules}: [miss]𝓛[ty]8670{Array} = 𝓟81{getLocalRules}(𝓟[ty]311{World},𝓟405{actor});
function 𝓟416{$Lambda12} (𝓟417{rule}): (𝓟418: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟418 = 𝓟232{checkTransitionMatch}(𝓟417{rule},𝓟405{actor})
}
const 𝓟419{transitionRules}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]311{World}.rules.filter(𝓟416{$Lambda12});
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟408{localActors}.length),𝓛12569{ExclamationToken}(𝓟406{results}.access(𝓟405{actor}.name))))
{
𝓟406{results}.access(𝓟405{actor}.name) ⟵ 𝓛8743{String};
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟415{localRules}.length),𝓛12569{ExclamationToken}(𝓟419{transitionRules}.length)),𝓛12569{ExclamationToken}(𝓟406{results}.access(𝓟405{actor}.name))))
{
𝓟406{results}.access(𝓟405{actor}.name) ⟵ 𝓛8743{String};
}
else
{
function 𝓟420{$Lambda13} (𝓟421{r}): (𝓟422: [miss]𝓛[ty]8655{Number})
{
return 𝓟422 = 𝓟421{r}.id
}
function 𝓟423{$Lambda14} (𝓟424{r}): (𝓟425: [miss]𝓛[ty]8655{Number})
{
return 𝓟425 = 𝓟424{r}.id
}
𝓟406{results}.access(𝓟405{actor}.name).TRANSITION_RULES ⟵ (𝓟406{results}.access(𝓟405{actor}.name).TRANSITION_RULES ? 𝓟301{unique}(𝓟406{results}.access(𝓟405{actor}.name).TRANSITION_RULES.concat(𝓟419{transitionRules}.map(𝓟420{$Lambda13}))) : 𝓟419{transitionRules}.map(𝓟423{$Lambda14});
𝓟406{results}.access(𝓟405{actor}.name).INTERACTION_RULES ⟵ {};
function 𝓟426{$Lambda15} (𝓟427{actorTwo}): (𝓟428: [miss]𝓛[ty]10033{Void})
{
𝓟406{results}.access(𝓟405{actor}.name).INTERACTION_RULES.access(𝓟427{actorTwo}.name) ⟵ 𝓛12546{BarBarToken}(𝓟406{results}.access(𝓟405{actor}.name).INTERACTION_RULES.access(𝓟427{actorTwo}.name),𝓛8757{Array}());
function 𝓟429{$Lambda16} (𝓟430{rule}): (𝓟431: [miss]𝓛[ty]10033{Void})
{
const 𝓟432{isMatch}: [miss]𝓛[ty]8666{Boolean} = 𝓟24{checkMatch}(𝓟430{rule},𝓟405{actor},𝓟427{actorTwo});
if (𝓛12592{AmpersandAmpersandToken}(𝓟432{isMatch},𝓛12559{EqualsEqualsEqualsToken}(𝓟406{results}.access(𝓟405{actor}.name).INTERACTION_RULES.access(𝓟427{actorTwo}.name).indexOf(𝓟430{rule}.id),𝓛12616{MinusToken}(𝓛8745{Number}))))
{
𝓟406{results}.access(𝓟405{actor}.name).INTERACTION_RULES.access(𝓟427{actorTwo}.name).push(𝓛12546{BarBarToken}(𝓟430{rule}.name,𝓟430{rule}.id))
}
}
𝓟415{localRules}.forEach(𝓟429{$Lambda16})
}
𝓟408{localActors}.forEach(𝓟426{$Lambda15})
}
}
}
}