Overcoming Alienation: A Journey to Self-Acceptance Inspired by Radiohead's 'Creep' • Llego.dev

Each day felt like a struggle, a difficult path toward accepting myself and finding where I belonged. Every step was uncertain, drawing me deeper into feelings of self-doubt, loneliness, and alienation. Comfort felt distant, and like the melody of Radiohead’s “Creep,” my heart echoed, “I’m a creep, I’m a weirdo. What the hell am I doing here? I don’t belong here.”

My gaze would shift from one face to another, each a stark reminder of a world where I felt out of place. A world that seemed to effortlessly bask in the sunshine, while my existence lingered in the shadows. Everyone appeared so radiant, so seemingly perfect, their brilliance almost blinding. I felt like a mere shadow within their light, yearning to be seen, to be noticed. Yet, my anxieties kept me hidden in the background.

Looking in the mirror was often an exercise in self-criticism. My own skin felt like something to reject, bringing me to tears. I longed for a transformation – a perfect body to house an ideal soul, hoping to finally validate my existence and gain control of my life’s direction. The pressure of societal expectations was so strong that I wanted to conform, to follow the expected path instead of creating my own.

These expectations weighed heavily on me, leading to frequent disappointment. My chest felt empty, echoing with unfulfilled dreams. I wore masks, hiding my true self behind a pretense of flamboyance – a way to fit in, to disappear into the crowd. But these masks were burdensome, hiding my true identity and stifling my authenticity.

While hiding behind this facade, I desperately wanted to be missed when I was absent – a desire intertwined with a powerful fear. The fear of rejection, of being overlooked, of being left to languish in my perceived imperfections. The thought, “I wish you would notice when I’m not around,” constantly played in my mind, a silent, heartfelt plea.

Each closed door, each person I wished to connect with but couldn’t, felt like a blow to my isolated existence. The sound of footsteps walking away amplified the silence within me, fueling my self-rejection. Every departure seemed to confirm my insecurities and the ways I didn’t fit into the world.

There were times when I felt completely lost in this despair. But in those moments, a difficult acceptance would surface. Others had the right to pursue their own paths and happiness, even if it didn’t include me. This realization, though harsh, brought a brutal understanding of my alienation. I wasn’t what they wanted or needed.

Yet, within this acceptance was a surprising strength – a resilience born from navigating these difficult emotions. Like the persistent character in Radiohead’s “Creep,” I felt trapped in a cycle of frustration, self-deprecation, and longing. This path seemed endless, yet it hinted at a possibility beyond – a distant hope of self-love and acceptance.

In this cycle, the phrase “I don’t belong here” slowly shifted. It became a question rather than a statement – a question I now believe I’m on the path to answering, exploring the uncertainties of life, carried by the haunting beauty of Radiohead’s “Creep.”

import random
import matplotlib.pyplot as plt
import pickle

class EmotionalState:
    """
    Represents the emotional state of an individual, tracking feelings and desires over time.
    """
    def __init__(self, resilience: int, sensitivity: int, optimism: int):
        """
        Initializes an EmotionalState object.

        Args:
            resilience:  Initial resilience level (0-10).
            sensitivity: Initial sensitivity level (0-10).
            optimism:    Initial optimism level (0-10).
        """
        self.attributes = {
            "resilience": resilience,
            "sensitivity": sensitivity,
            "optimism": optimism
        }
        self.init_feelings_and_desires()
        self.experiences = []
        self.relationships = {}
        self.feelings_over_time = self.init_over_time(self.feelings)
        self.desires_over_time = self.init_over_time(self.desires)

    def init_feelings_and_desires(self):
        """Initializes feelings and desires with a default value."""
        DEFAULT_VALUE = 5
        feelings_keys = ["doubt", "fear", "rejection", "joy", "excitement", "sadness", "anger"]
        desires_keys = ["acceptance", "belonging", "recognition", "achievement"]
        self.feelings = {key: DEFAULT_VALUE for key in feelings_keys}
        self.desires = {key: DEFAULT_VALUE for key in desires_keys}

    def init_over_time(self, indicator: dict):
        """Initializes a dictionary to track values over time."""
        return {key: [value] for key, value in indicator.items()}

    def calc_delta_and_update(self, indicators: dict, attr_mod: int, over_time: dict):
        """Calculates a random delta and updates indicator values."""
        attr_mod = abs(attr_mod)
        delta = 0
        while delta == 0:
            delta = random.randint(-attr_mod, attr_mod)
        for key, intensity in indicators.items():
            indicators[key] = max(0, min(10, intensity + delta))
            print(f"{key.capitalize()} intensity: {indicators[key]}")
            over_time[key].append(indicators[key])

    def feel(self):
        """Simulates the impact of emotions, influenced by resilience and sensitivity."""
        attr_mod = self.attributes["resilience"] if self.feelings["fear"] < 5 else self.attributes["sensitivity"]
        self.calc_delta_and_update(self.feelings, attr_mod, self.feelings_over_time)

    def desire(self):
        """Simulates the evolution of desires, influenced by optimism and resilience."""
        attr_mod = self.attributes["optimism"] if self.desires["acceptance"] < 5 else -self.attributes["resilience"]
        self.calc_delta_and_update(self.desires, attr_mod, self.desires_over_time)

    def experience(self, event: 'Event'):
        """Registers an experience and its impact on feelings and desires."""
        self.experiences.append(event)
        for item in event.impacts:
            if item in self.feelings:
                self.feelings[item] += event.intensity
            elif item in self.desires:
                self.desires[item] -= event.intensity

    def change_states(self, states: dict):
        """Simulates random fluctuations in emotional states based on recent experiences."""
        for experience in self.experiences[-5:]:
            for impact in experience.impacts:
                if impact in states:
                    states[impact] += random.randint(-2, 2)

    def interact(self, other: 'EmotionalState'):
        """Simulates an interaction with another individual, affecting feelings."""
        relationship = self.relationships.get(other, {"positivity": 5})
        positivity = relationship["positivity"]
        interaction_effect = {'self': 'joy', 'other': 'joy'} if positivity >= 5 else {'self': 'sadness', 'other': 'joy'}

        for role, emotion in interaction_effect.items():
            person = self if role == 'self' else other
            person.feelings[emotion] += positivity if emotion == 'joy' else -positivity

        self.relationships[other] = {"positivity": positivity + 1}
        other.relationships[self] = {"positivity": positivity + 1}

    def plot_feelings_and_desires(self):
        """Plots the change in feelings and desires over time."""
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
        for ax, obj_in_dict, title_in_plot in zip((ax1, ax2), (self.feelings_over_time, self.desires_over_time), ('Feelings Over Time', 'Desires Over Time')):
            for item, values in obj_in_dict.items():
                ax.plot(values, label=item)
            ax.set_xlabel('Day')
            ax.set_ylabel('Intensity')
            ax.set_title(title_in_plot)
            ax.legend()
        plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1)
        plt.show()
        return fig, None

    def save_state(self, filename: str):
        """Saves the current state of the EmotionalState object to a file."""
        fig, _ = self.plot_feelings_and_desires()
        plt.close(fig)
        with open(filename, 'wb') as f:
            pickle.dump(self, f)

    @staticmethod
    def load_state(filename: str):
        """Loads an EmotionalState object from a file."""
        with open(filename, 'rb') as f:
            return pickle.load(f)

    def __repr__(self):
        """Returns a string representation of the EmotionalState object."""
        return f"EmotionalState(resilience={self.attributes['resilience']}, sensitivity={self.attributes['sensitivity']}, optimism={self.attributes['optimism']})"

class Event:
    """Represents an event that can impact an individual's emotional state."""
    def __init__(self, name: str, impacts: list, intensity: int):
        """
        Initializes an Event object.

        Args:
            name:      The name of the event.
            impacts:   A list of feelings or desires impacted by the event.
            intensity: The intensity of the impact (positive or negative).
        """
        self.name = name
        self.impacts = impacts
        self.intensity = intensity

life_events = [
    Event("self-analysis", ["doubt", "fear"], 2),
    Event("wearing_mask", ["acceptance"], 3),
    Event("door_closed", ["rejection"], 5),
    Event("realization", ["acceptance", "belonging"], -5)
]

people = [EmotionalState(resilience=2, sensitivity=1, optimism=3) for _ in range(5)]

for index, person in enumerate(people):
    print(f"\nNew day for person with resilience {person.attributes['resilience']}, sensitivity {person.attributes['sensitivity']}, and optimism {person.attributes['optimism']}.")

    random_events = random.sample(life_events, 2)
    for event in random_events:
        print(f"\nExperiencing: {event.name}")
        person.experience(event)
        person.feel()
        person.desire()

    interaction = random.choice(people)
    if interaction != person:
        print(f"\nInteracting with another.")
        person.interact(interaction)
        person.feel()
        person.change_states(person.feelings)
        person.change_states(person.desires)

    fig, _ = person.plot_feelings_and_desires()

    person.save_state(f'person_{index}_state.pickle')