Final

For the final, I’m trying to combine Hypercinema and ICM to prototype a game that I eventually want to turn into a physical game, perhaps using a typewriter. The idea stemmed from when I started thinking about shows I have watched and the relationships in shows where two people see each other for who they are: ‘Fleabag’ and the ‘Priest’, ‘Connell’ and ‘Marianne’. I also thought of the fact that the ‘Priest’ from ‘Fleabag’ entered ‘Fleabag’s life as a manic pixie dream boy archetype, but eventually, we see his character. I thought of the show ‘Bear’, and then I realised Claire’s role also fit the manic pixie dream girl archetype. I started thinking of the nature of most relationships, and most people don’t really see you for who you are, they mostly love you for how you make them feel. I thought of the nature of letters. People mostly give letters on very specific occasions like birthdays, Valentine’s, or even when someone close to them passes away. There’s a particular type of novelty to letters. People don’t write letters otherwise. Then I came up with the idea of creating a letter-writing game. The player gets the option to select a character, an occasion or no occasion, and a bunch of phrases to choose from to construct the letter. Based on the letter, the person would get a response. If the nature of the letters is such that it’s less about loving the person for who they are and more about loving the idea of the person—the theme—the background becomes thematically darker. Objects such as an ashtray or other items start appearing, and the responses get vaguer. The person who writes loses once they stop getting responses. It is placed in a space such as a living room or kitchen counter so you can see the change depending on the occasion. I’m not entirely sure of the mechanics —whether I want to make this software or a physical interface. I plan to practice writing letters over winter break as and when I get time, and to build on the character and the permutations and combinations of receiving the response. Alanna told me to check out the game ‘Tender Creature Comfort’, ‘Tracery’ library in JavaScript and Twine.

I started thinking of a background that I might want to incorporate in my game. I started thinking of my desk as the best place to start. I don’t have a desk in New York, but this was my desk from one of the apartments that I lived in 2023. I had a similar desk setup even after I moved places, and this was the one space that consistently looked similar all throughout undergrad, even when I moved houses every year.

This is a sketch of how I want the players to experience the game when I design the space. I’m thinking of using Blender instead of Unity to create the space, since I can easily export it to p5.js or JavaScript if I design it in Blender.

I’ve been writing letters on my Substack, so it’s easy to keep track of the letters and get feedback on my writing. To plan my game mechanics further, I need to map out the letters for each relationship. This is, most roughly, what I’ve thought of relationships that I want to explore and occasions that I want to write for.

I spoke with Yuliya Parshina Kottas, and she told me to talk to Theo Ellin Ballew for more feedback on my writing and also said that, to get my game mechanics right, I should sketch more, use sticky notes, and make a storyboard.

More References:

• https://www.artic.edu/articles/1100/signed-sealed-delivered-correspondence-art

• https://en.wikipedia.org/wiki/Bertrand_Russell

• https://news.liverpool.ac.uk/2018/02/14/victorian-love-letters-from-the-archives/

However, now, due to time constraints, I couldn’t combine Hypercinema and ICM. Instead, I decided to combine Hypercinema with my Visual Journalism final. For ICM, though, I still wanted to work with the letters that I wrote and come up with something.

So after the classes where we focused on text and learnt about Markov chains, I came up with the idea of using Markov chains to test how letters feel like.

I first referenced the code from the class to come up with an initial sketch, but that didn’t work as well with letters. I realised I had written poems earlier, so I tried to make a poem generator. It didn’t work quite well, but it was really interesting to work with because I learnt a lot, a lot more about language, grammar, and repetitiveness in poems.

// Array of words
let words = [];
let topMargin = 100;
let leftMargin = 20;
let lineSpacing = 25;
// Word chain
let word_chain = {};
/* 

We will create a directory of word_chains that look something like this...

 {
   "I" : ["know", "want", "need", "need", forgot"],
   "know" : ["that", "it", "it"],
   "it" : ["is", "was", "won't", "is"],
   "is" : ["not", "so", "good", "good"]
 }
*/

// Current word
let current_word = '';

// New string
let str = '';
let str1 = '';
let str2 = '';
let str3 = '';
let str4 = '';

let wordcount = 0;

function preload() {
  randomSeed(33);
  loadStrings('poems.txt', count);
}


function setup() {
  createCanvas(400, 400);
  textFont("Courier New");
  fill(0,0,0);
  frameRate(20);
}


function draw() {
  textSize(8);
  textAlign(LEFT, CENTER);
  if (wordcount < 11) {
  let next_possible_words = word_chain[current_word];
  let next_word = random(next_possible_words);
  let next_word1 = random(next_possible_words);
  let next_word2 = random(next_possible_words);
  let next_word3 = random(next_possible_words);
  let next_word4 = random(next_possible_words);
  let words_to_skip = ['a', 'an', 'the', 'and', 'i', 'no', 'you', 'was', 
                       'it\'s', 'who', 'of', 'the', 'by', 'will', 'to', "as", "he", "am", "is", "your", "into", "my"];
    if (wordcount == 10) {
      if (words_to_skip.includes(next_word) || 
          words_to_skip.includes(next_word1) || 
          words_to_skip.includes(next_word2) || 
          words_to_skip.includes(next_word3) || 
          words_to_skip.includes(next_word4)) {
        return; 
      }
    }
  str += next_word + " "; 
  str1 += next_word1 + " "; 
  str2 += next_word2 + " "; 
  str3 += next_word3 + " "; 
  str4 += next_word4 + " "; 
  text(str, leftMargin, topMargin + lineSpacing*2);
  text(str1, leftMargin, topMargin + lineSpacing*3);
  text(str2, leftMargin, topMargin + lineSpacing*4);
  text(str3, leftMargin, topMargin + lineSpacing*6);
  text(str4, leftMargin, topMargin + lineSpacing*7);
  current_word = next_word;
  wordcount++;
}
}

function count(data) {
  // Go line by line
  for (let d of data) {
    // Turn each line into an array of words
    let line = splitTokens(d);
    // Add it to 1 big array
    words = words.concat(line);
  }

  // Clean up all the words
  for (let w = words.length-1; w >= 0; w--) {
    let word = words[w];
    // Remove punctuation
    word = word.replace(/[\-_:;.,!?\(\)\"\"\'\']/g, "");
    // Make it all lowercase
    word = word.toLowerCase();
    // Get rid of whitespace around the word
    word = word.trim();
    // If nothing is left, get rid of it
    if (word.length < 1) words.splice(w, 1);
    // Otherwise put cleaned up word back in array
    else words[w] = word;
  }
    
  // Collect all possible next words for each word
  for (let w = 0; w < words.length-1; w++) {
    let word = words[w];
    // Get the next word
    let next_word = words[w+1];
    // If this word has already been indexed, 
    // add the next word to its list of possible next words
    if (word in word_chain) word_chain[word].push(next_word);
    // Otherwise, start a new list
    else word_chain[word] = [next_word];
  }
  
  // Wrap last word around to beginning if it doesn't exist already in word_chain
  let last_word = words[words.length-1];
  let first_word = words[0];
  if(!(last_word in word_chain)) word_chain[last_word] = [first_word];
  
  // Print word count object
  // console.log(word_chain);
  // Start with a random word
  current_word = random(words);
}

function mousePressed() {
  str = '';
  str1 = '';
  str2 = '';
  str3 = '';
  str4 = '';
  wordcount = 0;
  background(255);
}

However, I still really wanted to work with letters, so I decided to look into more Markov chain libraries. That’s when I came across RiTa, which uses Markov chains for simple language processing and generation tasks and is an AI-free tool. It was relatively easy to work with. I took a while to figure out the nature of the texts I added, and I messed around a lot with the n-gram value. The higher n-gram value meant that the model chose between a path of 5 sentences. I also turned the disableInputChecks to true because I didn’t mind that the letters generated contained a lot of input sentences, rather than each sentence being a new one. Then, because this is a letter, it generates text with a sequence of 10 sentences. I used to write a bunch of poems earlier, which often consisted of two characters Luna and Sun, and I thought in this case, it would fit really well, because I thought Luna and Sun, can be compared to Moon and the Sun and the only meet at eclipse, and I liked that analogy, and I thought the love letters would make sense here till they meet. A lot of my writing has a lot of physics references, so making Luna a physicist seemed to fit best in this context. I also spent a while figuring out how to give it a typewriter effect, and for that, I used millis(), it is what I’ve tried before in Pcomp as well. I tried adding some generic opening sentences, but that didn’t work too well.