massive update

Author: AlaMonocake

eventRunner.js

@@ -0,0 +1,47 @@
+import { events } from './events.js';
+
+function processEventTemplate(template, context) {
+    return template.replace(/\{([a-zA-Z0-9_.]+)\}/g, (_, key) => {
+        const parts = key.split(".");
+        let value = context;
+        for (const part of parts) {
+            if (value && part in value) {
+                value = value[part];
+            } else {
+                return `{${key}}`; // leave if missing
+            }
+        }
+        return value;
+    });
+}
+
+export function runRandomEvent(participants) {
+    const aliveMasters = participants.filter(p => p.type === "master" && p.status === "alive");
+    const aliveServants = participants.filter(p => p.type === "servant" && p.status === "alive");
+
+    const randomMaster = aliveMasters[Math.floor(Math.random() * aliveMasters.length)];
+    const randomServant = participants.find(p => p.id === randomMaster.servantId);
+
+    const validEvents = events.filter(event => {
+        const validPool = event.valid(participants);
+        return validPool.includes(randomMaster);
+    });
+
+    if (validEvents.length === 0) {
+        console.warn("No valid events available.");
+        return;
+    }
+
+    const event = validEvents[Math.floor(Math.random() * validEvents.length)];
+
+    // Run effects
+    event.effects(randomMaster, randomServant, participants);
+
+    // Generate event text
+    const eventText = processEventTemplate(event.description, {
+        master: randomMaster,
+        servant: randomServant
+    });
+
+    console.log(eventText);
+}

events.js

@@ -0,0 +1,47 @@
+// events.js - Contains all event definitions for the simulation
+
+// Event pool array to store all events
+const eventPool = [
+    //Event 1: Master Death
+    {
+        id: "event_kill_master",
+        description: "{master} walks into a landmine and dies.",
+        type: "kill-master",
+        targets: ["master"], // Needs one master as the target
+        effect: (participants, master) => {
+            master.status = "dead"; // Mark master as dead
+            const servant = participants.find(p => p.type === "servant" && p.masterId === master.id);
+            if (servant && !servant.hasIndependentAction) {
+                servant.status = "dead"; // If the servant doesn't have Independent Action, they die too
+            }
+        }
+    },
+    // Event 2: Duel
+    {
+        id: "event_duel",
+        description: "{servant1} fights with {servant2} to the death.",
+        type: "duel",
+        targets: ["servant", "servant"], // Needs two servants as the targets
+        effect: (participants, servant1, servant2) => {
+            const loser = Math.random() < 0.5 ? servant1 : servant2;
+            loser.status = "dead"; // Randomly pick a servant to die
+        }
+    },
+    // Add more events here as needed...
+    {
+        id: "event_betrayal",
+        description: "{servant1} betrays {master}. The master is left defenseless and killed.",
+        type: "betrayal",
+        targets: ["servant", "master"],
+        effect: (participants, servant1, master) => {
+            if (servant1 && master) {
+                servant1.status = "alive"; // Servant survives
+                master.status = "dead"; // Master is dead
+            }
+        }
+    },
+    
+];
+
+// Export the eventPool so it can be used in other files
+export { eventPool };

script.js

@@ -1,3 +1,5 @@
+import { runRandomEvent } from './eventRunner.js';
+
 console.log("Checking if .master elements exist...");
 console.log(document.querySelectorAll(".master"));
 document.addEventListener("DOMContentLoaded", () => {
@@ -74,8 +76,8 @@ function populateServantDropdown(servantDataArray) {
         servantDataArray.forEach(servant => {
             const option = document.createElement("option");
             // Extract a shortname; if you have a better key, replace servant.name here
-        const shortName = servant.name.split(" ")[0];  // crude fallback: take first word like "Artoria"
-        option.value = shortName;  // store shortname for simulator matching
+        //const shortName = servant.name.split(" ")[0];  // crude fallback: take first word like "Artoria"
+        //option.value = shortName;  // store shortname for simulator matching
         option.textContent = servant.name;  // full display name for user
         option.dataset.id = servant.id;  // store numeric ID if needed later
             dropdown.appendChild(option);  // <-- fix here
@@ -163,9 +165,12 @@ function saveParticipantsAndStartSimulation() {
         let servantContainer = teamContainer.querySelector(".servant-selection");
 
         let nameInput = masterContainer.querySelector(".master-name");
+        let genderSelect = masterContainer.querySelector(".gender-select");
         let pictureEl = masterContainer.querySelector(".master-img");
 
         let name = nameInput ? nameInput.value.trim() || `Master ${index + 1}` : `Master ${index + 1}`;
+        let gender = genderSelect ? genderSelect.value : "nonbinary"; // fallback to nonbinary if missing
+        let pronouns = getPronouns(gender);
         let pictureUrl = pictureEl ? pictureEl.src : "";
 
         let servantDropdown = servantContainer ? servantContainer.querySelector(".servant-select") : null;
@@ -191,15 +196,29 @@ function saveParticipantsAndStartSimulation() {
         }
 
         let masterData = {
+            id: `master${index + 1}`,
             name: name,
+            gender: gender,
+            pronouns: pronouns,
             picture: pictureUrl,
             status: "alive",
             type: "master",
             servantId: servantId,
-            servantName: servantName
+        
+        };
+
+        let servantData = {
+            id: servantId,
+            name: servantName,
+            type: "servant",
+            status: "alive",
+            masterId: masterData.id,
+            hasIndependentAction: servantHasIndependentAction,
+            image: servantImage
         };
 
         participants.push(masterData);
+        participants.push(servantData);
     });
 
     console.log("Saved participants:", participants);
@@ -208,6 +227,15 @@ function saveParticipantsAndStartSimulation() {
     window.location.href = "simulation.html";
 }
 
+function getPronouns(gender) {
+    if (gender === "male") {
+        return { subject: "he", object: "him", possessive: "his" };
+    } else if (gender === "female") {
+        return { subject: "she", object: "her", possessive: "her" };
+    } else {
+        return { subject: "they", object: "them", possessive: "their" };
+    }
+}
 
 //code to attach the above function to the button:
 document.addEventListener("DOMContentLoaded", function () {
@@ -218,4 +246,66 @@ document.addEventListener("DOMContentLoaded", function () {
     } else {
         console.error("Start Simulation button not found!");
     }
-});
+});
+
+//the code to run random events follows...?
+let currentDay = 1;
+let pastEvents = [];  // store event IDs
+let participants = JSON.parse(localStorage.getItem("participants")) || [];
+
+function processEventTemplate(template, master, servant) {
+    return template
+        .replace(/{master.name}/g, master.name)
+        .replace(/{master.pronouns.subject}/g, master.pronouns.subject)
+        .replace(/{master.pronouns.object}/g, master.pronouns.object)
+        .replace(/{master.pronouns.possessive}/g, master.pronouns.possessive)
+        .replace(/{servant.name}/g, servant ? servant.name : "no servant");
+}
+
+function runDayEvents() {
+    const aliveMasters = participants.filter(p => p.type === "master" && p.status === "alive");
+    const aliveServants = participants.filter(p => p.type === "servant" && p.status === "alive");
+
+    console.log(`===== DAY ${currentDay} =====`);
+
+    aliveMasters.forEach(master => {
+        const servant = aliveServants.find(s => s.id === master.servantId);
+
+        const validEvents = events.filter(event => {
+            const validPool = event.valid(participants, pastEvents);
+            return validPool.includes(master);
+        });
+
+        if (validEvents.length === 0) {
+            console.log(`No valid events for ${master.name}`);
+            return;
+        }
+
+        const selectedEvent = validEvents[Math.floor(Math.random() * validEvents.length)];
+
+        // Apply effects
+        selectedEvent.effects(master, servant, participants);
+
+        // Save event id
+        pastEvents.push(selectedEvent.id);
+
+        // Display event text
+        const eventText = processEventTemplate(selectedEvent.description, master, servant);
+        console.log(eventText);
+
+        const logDiv = document.getElementById("event-log");
+        logDiv.innerHTML += `<p>Day ${currentDay}: ${eventText}</p>`;
+    });
+
+    currentDay++;
+}
+
+// Run day 1 immediately after load
+window.onload = () => {
+    runDayEvents();  // runs once for each master
+};
+
+// Button for next days
+document.getElementById("next-day").addEventListener("click", () => {
+    runDayEvents();  // runs once for each alive master
+});

simulation.html

@@ -21,6 +21,7 @@ <h2 id="day-counter">Day 1</h2>
 
         <button class="button" id="next-day">Proceed to Next Day</button>
     </main>
+    <script type="module" src="events.js"></script>
      <!-- The script to collect participants follows -->
      <script>
         function loadParticipants() {
@@ -75,6 +76,52 @@ <h2 id="day-counter">Day 1</h2>
         console.warn("No valid participants loaded.");
     }
 });
+
+//WE'RE DONE WITH THE ABOVE CODE. Now the event simulation code follows
+
+import { eventPool } from './events.js'; // Adjust the path if needed
+function runRandomEvent() {
+    // Ensure there are alive participants before running events
+    const aliveMasters = participants.filter(p => p.type === "master" && p.status === "alive");
+    const aliveServants = participants.filter(p => p.type === "servant" && p.status === "alive");
+
+    if (aliveMasters.length === 0) return;  // No more masters, game over
+    if (aliveServants.length === 0) return;  // No more servants, game over
+
+    // Randomly pick an event from the event pool
+    const event = eventPool[Math.floor(Math.random() * eventPool.length)];
+
+    // Select random participants for the event
+    let selected = [];
+    for (const targetType of event.targets) {
+        const pool = participants.filter(p => p.type === targetType && p.status === "alive");
+        if (pool.length === 0) return;  // Skip if no eligible targets
+        const pick = pool[Math.floor(Math.random() * pool.length)];
+        selected.push(pick);
+    }
+
+    // Apply the event's effect
+    event.effect(participants, ...selected);
+
+    // Log the event description
+    const description = event.description
+        .replace("{master}", selected[0]?.name || "Unknown")
+        .replace("{servant1}", selected[0]?.name || "Unknown")
+        .replace("{servant2}", selected[1]?.name || "Unknown");
+
+    console.log("Event:", description);
+    // Optionally log the event to a history
+    logEvent(description);
+
+    //THE EVENT HISTORY FOR DEBUGGING
+    let eventHistory = [];
+    function logEvent(description) {
+    eventHistory.push({ description, timestamp: new Date() });
+    console.log("Logged Event:", description);
+}
+
+}
+
     </script>
 </body>
 </html>