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

Creating and Analyzing Playable Narratives with Linear Logic

B6ff5f798c18a3367b2770aa3ada0730?s=47 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.

B6ff5f798c18a3367b2770aa3ada0730?s=128

Chris

April 21, 2015
Tweet

More Decks by Chris

Other Decks in Research

Transcript

  1. Creating and Analyzing! Playable Narratives! with Linear Logic Chris Martens

    1 Graphics Lab, CMU April 21, 2015
  2. Creating and Analyzing! Playable Narratives! with Linear Logic Chris Martens

    2 Graphics Lab, CMU April 21, 2015
  3. 3 Parable of the Polygons (Vi Hart and Nicky Case)

  4. 4 Causal Understanding

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

    Extended example: Shakespeare World 3. Ongoing work: playable specifications
  6. 6 1. FORMS OF NARRATIVE PLAY

  7. 7 branching stories

  8. 8 branching stories Twine (twinery.org)

  9. 9

  10. 10 Sam Kabo Ashwell: “Standard Patterns in Choice-Based Games"

  11. 11 Sam Kabo Ashwell: “Standard Patterns in Choice-Based Games"

  12. 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!
  13. 13 What’s the structure of a stateful story?

  14. 14

  15. 15 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ Petri Net

  16. 16 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ permanent states

    Petri Net
  17. 17 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ Petri Net

  18. 18 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ Petri Net

  19. 19 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ Petri Net

  20. 20 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ choice between

    actions Petri Net
  21. 21 JRWRIR\HU RSHQFDELQHW JRWRGHQ NH\ IR\HU ZLQ GHQ Petri Net

  22. 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.
  23. 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”
  24. 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
  25. 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
  26. 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
  27. 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
  28. 28 another form of narrative play

  29. 29 greet insult compliment gossip reject ... social verbs: social

    state: knowledge sentiment emotional state personality beliefs goals
  30. 30 aka “character-driven” “emergent” “combinatorial” COMPOSITIONAL NARRATIVE

  31. 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!
  32. 32 COMPOSITIONAL NARRATIVE Research question: How can we provide computational

    support to authoring, understanding the structure of, and playing with compositional narratives?
  33. 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?
  34. 34 Outline: ! 1. Background: forms of narrative play 2.

    Extended example: Shakespeare World 3. Ongoing work: playable specifications
  35. 35 II. EXTENDED EXAMPLE: SHAKESPEAREAN TRAGEDY STORY WORLD

  36. 36 at <character> <location> has <character> <object> anger <character> <character>

    affection <character> <character> depressed <character> dead <character> World state:
  37. 37 insult: ➡️

  38. 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.!
  39. 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)
  40. 40 do/insult : ! $at C L * $at C’

    L 
 * $anger C C’! -o anger C’ C 
 * depressed C’.! for all C, C’, L
  41. 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)
  42. 42 Main idea of this section: Use linear logic programming

    (computation = proof search) to generate narratives over a space specified by rules.
  43. 43 compliment: ➡️

  44. 44 ➡️ travel_toward:

  45. 45 murder: ! ! ➡️

  46. 46 loot: ➡️

  47. 47

  48. 48 initial state !adjacent mon_house town.! !adjacent town mon_house.! !adjacent

    cap_house town.! !adjacent town cap_house.!
  49. 49

  50. 50

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

    B Δ = arbitrary context of resources A1, …, An
  52. 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
  53. Program Execution 53 At the end we get: ! Δ

    , the final context ! a trace of rules applied (sequence of narrative actions, AKA story!) n
  54. 54 x0 : p(romeo,juliet) x1 : q x2 : r

    =
  55. 55 rule : p(C,C’) * q -o s(C) x0 :

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

    x1 : q x2 : r rule : p(C,C’) * q -o s(C)
  57. 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)
  58. 58 x3 : s(romeo) x2 : r let x3 =

    rule x0 x1 … rule2 : r * s(C) -o t(C) * u
  59. 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
  60. Nondeterminism 60 A -o B Δ, B A -o C

    Δ, C Δ, A
  61. 61 A -o B C -o D

  62. 62 A -o B C -o D Δ, B, C

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

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

    Δ, A, D Δ, A, C Δ, B, D r1 r2 r2 r1
  65. 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
  66. 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
  67. 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
  68. 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
  69. 69 program traces are! causally-structured stories

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

    Extended example: Shakespeare World 3. Ongoing work: playable specifications
  71. 71 3. ONGOING WORK: PLAYABLE SPECIFICATIONS

  72. 72 accessible tools for making games

  73. 73 PuzzleScript

  74. 74

  75. 75

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

    [ PlayerBodyH | PlayerHead1 ] sfx2
  77. 77 Idea: Replace nondeterminism in the system with human interactor

    choice.
  78. 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).
  79. 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).
  80. 80 CEPTRE 3 additions to the core language: ! sensing

    predicates acting predicates stages
  81. 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
  82. 82 ONGOING/FUTURE WORK

  83. 83 language implementation https://github.com/chrisamaphone/interactive-lp

  84. 84 emergent systems have lots of corner cases => bugs!

  85. 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?
  86. 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?
  87. 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))
  88. 88 CONCLUSION

  89. 89 Method: Linear logic programming + proof theory ! Results:

    1. Structured narrative generation 2. Playable narratives and game sketches
  90. 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.
  91. 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!
  92. Extra Slides 92

  93. 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?
  94. 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)
  95. 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)
  96. 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!)
  97. 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?