Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Creating and Analyzing Playable Narratives with Linear Logic

Chris
April 21, 2015

Creating and Analyzing Playable Narratives with Linear Logic

Computational procedures afford us with a rich design space of narratives that can be explored and played in a variety of ways, and interactive narrative as a field has the potential to help humans understand complex systems of causality. But we need better tools for authoring and conceptualizing playable narratives, especially those that arise from multiple story agents acting interdependently.

I illustrate how linear logic, a general formalism with ties to
computational concurrency, can be used to encode a narrative space in such a way that we can a) run a proof search algorithm to generate different narratives, and b) analyze causal structure. I will then discuss ongoing work in developing a programming language based on linear logic, with the aim of supporting a broad range of idioms in interactive simulation and game design.

Chris

April 21, 2015
Tweet

More Decks by Chris

Other Decks in Research

Transcript

  1. 5 Outline: ! 1. Background: forms of narrative play 2.

    Extended example: Shakespeare World 3. Ongoing work: playable specifications
  2. 9

  3. 12 branching stories with state foyer: (set:$key = true) You

    found a key! [[den]] ! den: (if: not $key)[There is a cabinet here, but you can't open it.] (else: )[There's a cabinet here. [[open it]] ] [[foyer]] ! open it: yay cabinet!
  4. 14

  5. 22 Linear Logic go_to_foyer : in_den -o in_foyer * !key.

    go_to_den : in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open.
  6. 23 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

    in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “atoms” or “(atomic) resources”
  7. 24 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

    in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “lolli:” linear implication
  8. 25 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

    in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic antecedents and consequents
  9. 26 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

    in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “tensor:” resource conjunction
  10. 27 go_to_foyer : in_den -o in_foyer * !key. go_to_den :

    in_foyer -o in_den. open_cabinet : in_den * key -o in_den * !cabinet_open. Linear Logic “bang:” persistent resources
  11. 29 greet insult compliment gossip reject ... social verbs: social

    state: knowledge sentiment emotional state personality beliefs goals
  12. 31 aka “character-driven” “emergent” “combinatorial” COMPOSITIONAL NARRATIVE One rule might

    be applied several times, each in a different narrative state. ! Thus: rules must be parametric over narrative states!
  13. 32 COMPOSITIONAL NARRATIVE Research question: How can we provide computational

    support to authoring, understanding the structure of, and playing with compositional narratives?
  14. 33 COMPOSITIONAL NARRATIVE Answer in progress: programming language(s) based on

    linear logic. Research question: How can we provide computational support to authoring, understanding the structure of, and playing with compositional narratives?
  15. 34 Outline: ! 1. Background: forms of narrative play 2.

    Extended example: Shakespeare World 3. Ongoing work: playable specifications
  16. 36 at <character> <location> has <character> <object> anger <character> <character>

    affection <character> <character> depressed <character> dead <character> World state:
  17. 38 do/insult : ! at Alice L * at Eliza

    L 
 * anger Alice Eliza! -o ! at Alice L * at Eliza L 
 * anger Alice Eliza
 * anger Eliza Alice 
 * depressed Eliza.!
  18. 39 do/insult : ! $at Alice L * $at Eliza

    L 
 * $anger Alice Eliza! -o ! anger Eliza Alice 
 * depressed Eliza.! (notation: $ for resources we want to keep)
  19. 40 do/insult : ! $at C L * $at C’

    L 
 * $anger C C’! -o anger C’ C 
 * depressed C’.! for all C, C’, L
  20. 41 do/insult : ! $at C L * $at C’

    L 
 * $anger C C’! -o anger C’ C 
 * depressed C’.! for all C, C’, L Logic Programming! (aka Relational Programming)
  21. 42 Main idea of this section: Use linear logic programming

    (computation = proof search) to generate narratives over a space specified by rules.
  22. 47

  23. 49

  24. 50

  25. Program Execution 51 A -o B Δ, A → Δ,

    B Δ = arbitrary context of resources A1, …, An
  26. 52 6 6¶ 6R6¶  U6R6¶    Q

     /RJLF3URJUDP LQLWLDOVWDWH Program execution in CLF (Watkins et al. 2002) as realized by Celf (Schack-Nielsen & Schürmann 2008) quiescence
  27. Program Execution 53 At the end we get: ! Δ

    , the final context ! a trace of rules applied (sequence of narrative actions, AKA story!) n
  28. 55 rule : p(C,C’) * q -o s(C) x0 :

    p(romeo,juliet) x1 : q x2 : r
  29. 56 x3 : s(romeo) x2 : r x0 : p(romeo,juliet)

    x1 : q x2 : r rule : p(C,C’) * q -o s(C)
  30. 57 let x3 = rule x0 x1 … x0 :

    p(romeo,juliet) x1 : q x2 : r x3 : s(romeo) x2 : r rule : p(C,C’) * q -o s(C)
  31. 58 x3 : s(romeo) x2 : r let x3 =

    rule x0 x1 … rule2 : r * s(C) -o t(C) * u
  32. 59 let x3 = rule x0 x1 let [x4, x5]

    = rule2 x2 x3 … x4 : t(romeo) x5 : u x3 : s(romeo) x2 : r rule2 : r * s(C) -o t(C) * u
  33. 62 A -o B C -o D Δ, B, C

    Δ, A, D Δ, A, C
  34. 63 A -o B C -o D Δ, B, C

    Δ, A, D Δ, A, C Δ, B, D
  35. 64 A -o B C -o D Δ, B, C

    Δ, A, D Δ, A, C Δ, B, D r1 r2 r2 r1
  36. 65 A -o B C -o D Δ, B, C

    Δ, A, D Δ, A, C Δ, B, D r1 r2 r2 r1 let y1 = r1 x1 let y2 = r2 x2 in E let y2 = r2 x2 let y1 = r1 x1 in E
  37. 66 Δ, B, C Δ, A, D Δ, A, C

    Δ, B, D r1 r2 r2 r1 Concurrent Equality = let y1 = r1 x1 let y2 = r2 x2 in E let y2 = r2 x2 let y1 = r1 x1 in E
  38. 67 y1:B y2:D r1 r2 let y2 = r2 x2

    let y1 = r1 x1 in E let y1 = r1 x1 let y2 = r2 x2 in E x1:A x2:C
  39. 68 @KšEJOQHP PU>=HP¡ NKIAK¡ PKSJ¡ =JCAN @Kš?KILHEIAJP JQNOA¡ FQHEAP¡ 

    ?=L‹DKQOA¡ @KšPN=RAH NKIAK¡ PKSJ¡  ?=L‹DKQOA¡ HEGAO =P =JCAN =JCAN HEGAO HEGAO HEGAO HEGAO HEGAO @Kš?KILHEIAJP FQHEAP¡ NKIAK¡ =P =P =P =P =P =P =P =P =P =P
  40. 70 Outline: ! 1. Background: forms of narrative play 2.

    Extended example: Shakespeare World 3. Ongoing work: playable specifications
  41. 74

  42. 75

  43. 76 Horizontal [ > Player | No Obstacle ] ->

    [ PlayerBodyH | PlayerHead1 ] sfx2
  44. 78 move/up/red : move up * at L (player_head red)

    -o at L (player_head red). ! move/up : move up * at L (player_head C) * next C C' * adj L up L' * empty L' -o -o at L player_body * at L' (player_head L’). ! move/r : move right * at L (player_head C) * adj L right L' * empty L' -o at L player_body * at L' (player_head lime). ! move/l : move left * at L (player_head C) * adj L left L' * empty L' -o at L player_body * at L' (player_head lime). ! % gravity gravity : at L (player_head C) * adj L down L' * empty L' -o at L player_body * at L' (player_head C).
  45. 79 move/up/red : move up * at L (player_head red)

    -o at L (player_head red). ! move/up : move up * at L (player_head C) * next C C' * adj L up L' * empty L' -o -o at L player_body * at L' (player_head L’). ! move/r : move right * at L (player_head C) * adj L right L' * empty L' -o at L player_body * at L' (player_head lime). ! move/l : move left * at L (player_head C) * adj L left L' * empty L' -o at L player_body * at L' (player_head lime). ! % gravity gravity : at L (player_head C) * adj L down L' * empty L' -o at L player_body * at L' (player_head C).
  46. 80 CEPTRE 3 additions to the core language: ! sensing

    predicates acting predicates stages
  47. 81 targeted applications: ! 1. game design: easily combine rules

    from many domains; invent new mechanics and game logics ! 2. distributed algorithms & systems: easily prototype and experiment with local rules and their global behavior
  48. 85 Reasoning Tools ! 1. Statistical analysis of sets of

    traces 2. Invariant, precondition, and postcondition checking for stages (static or dynamic) 3. Exhaustive analysis (model checking) for certain fragments of the language?
  49. 86 Reasoning Tools ! 1. Statistical analysis of sets of

    traces 2. Invariant, precondition, and postcondition checking for stages (static or dynamic) 3. Exhaustive analysis (model checking) for certain fragments of the language?
  50. 87 Invariant Checking Example: “Whenever the player can reach a

    locked door, she can also reach its key.” ! for all doors D, reachable(player,D) => reachable(player, key(D))
  51. 89 Method: Linear logic programming + proof theory ! Results:

    1. Structured narrative generation 2. Playable narratives and game sketches
  52. 90 Takeaway: ! Programming languages based on logic can bring

    rules, narrative, and code into closer alignment, which aids prototyping, testing, and reasoning of compositional simulations.
  53. 91 Questions? 7ZLQH %UDQFKLQJ VWRU\ JUDSKV 6WDWHIXO 6WRULHV (PHUJHQW VWRU\WHOOLQJ

    7KHDWULFV 3URP :HHN 7KH6LPV /LQHDU /RJLF 3HWUL1HWV &/)&HOI SURJUDPPLQJ ODQJXDJH 7KHVLV VWDWHPHQW 5HVHDUFK 4XHVWLRQ (YLGHQFHIRU GHVLJQWRROSDUW RIWKHVLV VWDWHPHQW UHDVRQLQJ WRROV EXJV &HSWUH VHQVLQJ SUHGLFDWHV 3X]]OH6FULSW (YLGHQFHIRU SURWRW\SLQJDQG DQDO\VLVSDUWRI WKHVLVVWDWHPHQW 3DUW 3DUW 3DUW &/) WUDFHVSURRIV 3URRIVDV VWRULHV 6KDNHVSHDUH ZRUOG /RJLF 3URJUDPPLQJ &RQFXUUHQW VWUXFWXUH Thanks!
  54. 93 Open Q: ! What is the narrative structure of,

    say, a classic arcade game or single-player RPG? ! Is this structure useful to a designer?
  55. 94 Hypothesis: ! Concurrent structure of play traces will not

    be all that interesting (modulo independently-acting NPCs) ! …but Petri Net structure of the rules might be: feedback loops, “orphan verbs,” resource accumulation properties, other design features (& bugs)
  56. 95 Proof search: ! To run a query \Delta |-

    B ! Seed \Delta_0 = \Delta Run to quiescence to get \Delta’ Check whether \Delta’ contains everything in B (and nothing more)
  57. 96 So for instance I could codify endings in Shakespeare

    world like: ! married A B * dead C -o ending ! then do a query for ! init -o ending ! (in fact this is what I did since Celf doesn’t support traces for goalless queries!)
  58. 97 Tamara Participatory theatre in which participants may follow any

    character when they exit a scene ! Many concurrent + reconverging scenes — concurrent structure! ! CLF as dramaturgy tool?