copy from old repo

README.md

@@ -1,2 +1,127 @@
-# mis-interpreter
+# Mis-interpreter
 
+*A multiplayer code-telephone game where meaning drifts through obfuscation and reinterpretation.*
+
+---
+
+## Overview
+
+Mis-interpreter is an online, multi-user game inspired by the mechanics of *Telestrations* and the *Telephone Game*.
+Instead of drawings, players exchange short programs. Each round, code is obfuscated, interpreted in plain language, and re-implemented. By the end, the final program often diverges significantly from the original.
+
+---
+
+## How It Works
+
+### 1. Prompt Stage
+
+* Each player begins with a simple coding task (e.g., *“Write a function that reverses a string”*).
+* They implement a short snippet in the chosen language.
+
+### 2. Obfuscation & Pass
+
+* The system automatically **obfuscates** the code before passing it along.
+
+  * Variable renaming
+  * Minification or unusual formatting
+  * Redundant no-ops
+  * Structural rewrites (e.g., loops → recursion)
+
+### 3. Interpretation Stage
+
+* The next player receives the obfuscated code.
+* They provide a plain-language description of what they believe the code does.
+
+### 4. Re-Implementation Stage
+
+* Another player receives only the description.
+* They re-implement the code from scratch, based on that description.
+
+### 5. Repeat Cycle
+
+* This sequence of **code → obfuscation → description → rewrite** continues until every player has contributed.
+
+### 6. Reveal Stage
+
+* At the end of the round, the entire chain is shown:
+
+  1. The original prompt
+  2. The original code
+  3. Each obfuscated version
+  4. Each interpretation and re-implementation
+
+---
+
+## Scoring Modes
+
+### Casual Mode
+
+* No points. The focus is on comparing the original with the final result.
+
+### Competitive Mode
+
+* Points for **accurate descriptions** (does the description match the code’s actual behavior?).
+* Points for **faithful re-implementations** (does the new code behave the same as the last version?).
+* Optional bonus points for creative or surprising outcomes (voted by players).
+
+---
+
+## Technical Features
+
+* **Sandboxed execution** for safety.
+* **Languages**: initial support for Python and JavaScript.
+* **Obfuscation engine**: automated code transformations at each pass.
+* **Multiplayer lobbies**: recommended 4–10 players.
+* **Reveal timeline**: shows the progression step by step.
+
+---
+
+## Example Round
+
+**Prompt:** “Write code that sums a list of numbers.”
+
+1. Player A →
+
+   ```python
+   def sum_list(nums): return sum(nums)
+   ```
+
+2. Obfuscated →
+
+   ```python
+   def Q(q): R=0
+       for i in q: R+=i
+       return R
+   ```
+
+3. Player B (description) → “This adds up numbers in a list.”
+
+4. Player C (rewrite) →
+
+   ```javascript
+   function addAll(arr) {
+       let t=0;
+       for (const a of arr) { t+=a; }
+       return t;
+   }
+   ```
+
+5. Obfuscated again →
+
+   ```javascript
+   function f(a){return a.reduce((x,y)=>x+y,0)}
+   ```
+
+6. Player D (description) → “This concatenates strings together.”
+
+…and the cycle continues.
+
+---
+
+## Purpose
+
+Mis-interpreter explores how intent changes as code passes through transformations, interpretations, and rewrites. It combines programming practice with collaborative play and emphasizes how easily meaning can shift.
+
+---
+
+Would you like me to also produce a **short “Quick Rules” reference** (one section players can skim before starting), alongside this more detailed doc?