Animal game v.2 with gui

import tkinter as tk
from tkinter import simpledialog, messagebox
import pickle
import os

class Node:
    def __init__(self, question=None, animal=None):
        self.question = question
        self.animal = animal
        self.yes = None
        self.no = None

    def is_leaf(self):
        return self.animal is not None

class AnimalGuesserApp:
    def __init__(self, master):
        self.master = master
        self.master.title(“Animal Guesser”)
        self.master.geometry(“500×300”)
        self.master.option_add(“*Font”, “Arial 16”)

        self.label = tk.Message(master, text=””, width=460)
        self.label.pack(pady=30)

        btn_frame = tk.Frame(master)
        btn_frame.pack()

        self.yes_button = tk.Button(btn_frame, text=”Yes”, width=10, command=self.handle_yes)
        self.no_button = tk.Button(btn_frame, text=”No”, width=10, command=self.handle_no)

        self.yes_button.pack(side=”left”, padx=20)
        self.no_button.pack(side=”right”, padx=20)

        self.tree = self.load_tree()
        self.current_node = self.tree
        self.parent_stack = []  # Track the path for updating
        self.mode = “ask”  # ask / learn / done

        self.display_current()

    def display_current(self):
        if self.current_node.is_leaf():
            self.label.config(text=f”Is it a {self.current_node.animal}?”)
            self.mode = “guess”
        else:
            self.label.config(text=self.current_node.question)
            self.mode = “ask”

    def handle_yes(self):
        if self.mode == “ask”:
            self.parent_stack.append((self.current_node, True))
            self.current_node = self.current_node.yes
            self.display_current()

        elif self.mode == “guess”:
            self.label.config(text=”Yay! I guessed it!\nPlay again?”)
            self.mode = “done”

        elif self.mode == “done”:
            self.reset_game()

        elif self.mode == “learn_step2”:
            # user answered yes to: “for the new animal, what’s the answer?”
            self.insert_new_knowledge(True)

    def handle_no(self):
        if self.mode == “ask”:
            self.parent_stack.append((self.current_node, False))
            self.current_node = self.current_node.no
            self.display_current()

        elif self.mode == “guess”:
            self.start_learning()

        elif self.mode == “done”:
            self.master.quit()

        elif self.mode == “learn_step2”:
            # user answered no to: “for the new animal, what’s the answer?”
            self.insert_new_knowledge(False)

    def start_learning(self):
        self.new_animal = simpledialog.askstring(“Teach me”, “I give up! What animal were you thinking of?”)
        if not self.new_animal:
            self.label.config(text=”Okay, I’ll try better next time.\nPlay again?”)
            self.mode = “done”
            return

        self.new_question = simpledialog.askstring(“Help me learn”, f”Give me a yes/no question to tell a {self.new_animal} from a {self.current_node.animal}”)
        if not self.new_question:
            self.label.config(text=”No worries. Want to play again?”)
            self.mode = “done”
            return

        self.label.config(text=f”For a {self.new_animal}, what is the answer to your question?”)
        self.mode = “learn_step2”

    def insert_new_knowledge(self, new_animal_answer_yes):
        new_node = Node(question=self.new_question)
        if new_animal_answer_yes:
            new_node.yes = Node(animal=self.new_animal)
            new_node.no = self.current_node
        else:
            new_node.no = Node(animal=self.new_animal)
            new_node.yes = self.current_node

        # Attach new node to parent
        if self.parent_stack:
            parent, went_yes = self.parent_stack[-1]
            if went_yes:
                parent.yes = new_node
            else:
                parent.no = new_node
        else:
            self.tree = new_node  # Root replaced

        self.save_tree()
        self.label.config(text=”Thanks! I’ve learned something new.\nPlay again?”)
        self.mode = “done”

    def reset_game(self):
        self.current_node = self.tree
        self.parent_stack = []
        self.display_current()

    def save_tree(self, filename=”animal_tree.pkl”):
        with open(filename, “wb”) as f:
            pickle.dump(self.tree, f)

    def load_tree(self, filename=”animal_tree.pkl”):
        if os.path.exists(filename):
            with open(filename, “rb”) as f:
                return pickle.load(f)
        else:
            return Node(animal=”cat”)

if __name__ == “__main__”:
    root = tk.Tk()
    app = AnimalGuesserApp(root)
    root.mainloop()

Animal game (using pickle) in pydroid

import pickle
import os

class Node:
    def __init__(self, question=None, animal=None):
        self.question = question
        self.animal = animal
        self.yes = None
        self.no = None

    def is_leaf(self):
        return self.animal is not None

def ask_yes_no(prompt):
    while True:
        ans = input(prompt + ” (y/n): “).strip().lower()
        if ans in [‘y’, ‘yes’]:
            return True
        elif ans in [‘n’, ‘no’]:
            return False
        print(“Please enter y or n.”)

def play(node):
    if node.is_leaf():
        if ask_yes_no(f”Is it a {node.animal}?”):
            print(“Yay! I guessed it!”)
            return node
        else:
            return learn(node)
    else:
        if ask_yes_no(node.question):
            node.yes = play(node.yes)
        else:
            node.no = play(node.no)
        return node

def learn(old_node):
    new_animal = input(“I give up! What animal were you thinking of? “).strip()
    question = input(f”Give me a yes/no question to tell a {new_animal} from a {old_node.animal}: “).strip()
    if ask_yes_no(f”For a {new_animal}, what is the answer to your question?”):
        new_node = Node(question=question)
        new_node.yes = Node(animal=new_animal)
        new_node.no = old_node
    else:
        new_node = Node(question=question)
        new_node.no = Node(animal=new_animal)
        new_node.yes = old_node
    print(“Thanks! I’ll remember that.”)
    return new_node

def save_tree(tree, filename=”animal_tree.pkl”):
    with open(filename, “wb”) as f:
        pickle.dump(tree, f)

def load_tree(filename=”animal_tree.pkl”):
    if os.path.exists(filename):
        with open(filename, “rb”) as f:
            return pickle.load(f)
    else:
        # Start with a default animal
        return Node(animal=”cat”)

def main():
    print(“Think of an animal, and I’ll try to guess it!”)
    tree = load_tree()
    tree = play(tree)
    save_tree(tree)

if __name__ == “__main__”:
    while True:
        main()
        if not ask_yes_no(“Play again?”):
            break

Bat flying test pydroid

import pygame
import math
import sys

# Initialize Pygame
pygame.init()

# Set screen size
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption(“Flying Bat”)

clock = pygame.time.Clock()

# Bat position
x = 0
y = HEIGHT // 2

# Wing flap variables
wing_angle = 0
flap_speed = 0.15

# Colors
BLACK = (0, 0, 0)
DARK_GREY = (50, 50, 50)
WHITE = (255, 255, 255)

def draw_bat(surface, x, y, angle):
    body_width = 40
    body_height = 20

    # Draw bat body
    pygame.draw.ellipse(surface, DARK_GREY, (x, y, body_width, body_height))

    # Left wing
    left_points = [
        (x + 10, y + 10),
        (x – 30, y – 10 – int(math.sin(angle) * 20)),
        (x – 10, y + 10),
    ]
    pygame.draw.polygon(surface, DARK_GREY, left_points)

    # Right wing
    right_points = [
        (x + 30, y + 10),
        (x + 70, y – 10 – int(math.sin(angle) * 20)),
        (x + 50, y + 10),
    ]
    pygame.draw.polygon(surface, DARK_GREY, right_points)

# Main loop
running = True
while running:
    screen.fill(BLACK)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Animate
    wing_angle += flap_speed
    x += 3
    if x > WIDTH:
        x = -60  # Reset when offscreen

    draw_bat(screen, x, y + int(math.sin(wing_angle) * 10), wing_angle)

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()

20635

August 2nd — morning washed past unnoticed, the alarm dismissed or never heard, sunlight already pooling golden across the floorboards when I finally stirred. No rush to remedy it. No guilt, either. Just the soft stretch of limbs and the rumble of a hungry cat beside me, kneading the blanket like she was trying to start a fire.

Stayed in, mostly. Let the outside world whirl on without me. It can do that sometimes — spin its errands and alerts, calls and clicks — while I remain in sanctuary. A thick book in hand, the one with the creased spine and the smell of old paper. Stories folded in like origami secrets, each page a quiet hour.

Cat got her zoomies around noon. Dashed from one end of the apartment to the other like a tiny lion with invisible prey. He’s learned how to open cabinet doors, now. Keeps trying to break into the snacks — smart paws, soft menace.

Shared a little tuna as a peace offering. Sge forgave the late breakfast.

No mail worth mentioning. No visitors. Just the wind at the window and the occasional creak of a settling building. Sometimes, the best days don’t go anywhere. They just hold still and let you breathe.

Day 20,634

Friday draped in haze, wearing its quiet like a loose shirt.

Waited this morning from 10 to noon for a crew that never came. The kind of waiting where you second-guess every sound outside — leaf blower? delivery? redemption? — and end up just pacing and rereading the same sentence three times. Gave up eventually, but not before having a small conversation with a squirrel on the fence. He seemed equally unimpressed by the lack of progress.

Once free of obligation, wandered a while. Took the back way through the trees where the ground still holds last night’s rain, and the mushrooms are staging their slow uprising. One looked like a tiny red umbrella, forgotten by a fairy with better things to do. Passed someone walking two dogs — one anxious, one confident — a duo that reminded me of most of my decision-making process.

Drew for a bit this afternoon. Nothing profound — just lines and loops, loose shapes turning into something vaguely owl-like. Or maybe a spaceship. Sometimes it’s better not to know what it is while it’s still becoming.

Saw a fox print in the mud, sharp and fresh. No fox in sight, just the echo of movement. That felt about right for today — evidence of life passing by, quietly, while you’re looking the other way.

Tonight? Windows cracked open, low hum of crickets tuning up for their set. Might read, might not. Might just sit still and let the dark arrive on its own time.

No grand revelations. Just breath, breeze, and a sense that things are still turning, even when you’re paused.

Day 20,633

thick heat & hazy gold light

Woke up late, which isn’t usual, but maybe necessary. The air was already syrupy with warmth, pressing in through the windows before I’d even had a sip of coffee. Sat with the fan buzzing like a lazy hornet, flipping through a dog-eared field guide of native plants. There’s comfort in names—sweetspire, ironweed, bloodroot—like knowing the password to the green parts of the world.

Walked a slow loop in the early afternoon. The shade was a mercy. Dragonflies hovered like living stitches over puddles that hadn’t fully surrendered to the sun. Heard a woodpecker knocking at something deep in the trees—each tap like a code I couldn’t quite translate.

Pulled a single rune today: Laguz — water, intuition, the hidden current.
Fitting. Everything today felt submerged, like looking at life through a murky lens. Not unpleasant, just… deeper. Like something’s stirring below the surface.

Listened to an old radio drama while sorting through laundry in my closet.  One of those crackly, noir-voiced tales full of long shadows and double-crosses. Felt strangely comforting. The kind of story where nobody’s innocent but someone always tries to do right, even if it’s messy.

Dinner was roasted vegetables, chilled white bean salad, a chunk of bread big enough to be dangerous. Kept it simple. Let the quiet fill the space.

Now the cicadas are singing their electric hymn outside, and the sky’s starting to bruise at the edges. Might write a letter I’ll never send. Might just sit and listen.

🌒 Let the tide carry you, dear journal

Wednesday | overcast skies & silent crows

Woke up to the thrum of cicadas and the soft hush of gray cloud cover. Felt like the kind of day where the world takes a breath and holds it. Grabbed a can of diet orange vanilla coke, watched the cold mist curl out like old ghost stories, and wandered out for a morning walk along the Roanoke Greenway. Damp earth, mossy edges, and that sweet loamy scent of things growing just out of sight. One crow called out from a telephone wire and another answered across the river. Not sure if they were arguing or conspiring, but it felt important.

A quiet sense of being observed all day—not in a paranoid way, but like the trees were noting my presence. Probably just the caffeine and overactive imagination playing tag.

Read a few pages from a pulp horror zine someone left in the free little library—ink smudged, cover half torn, but perfect in its way. Story was about a sentient fog that eats memories. Kept thinking about that all afternoon. What would it take to let go of a memory willingly?

Dinner was black beans, hot sauce, and a grilled plantain. Simple. Good. Enough.

Thinking about making a zine of my own again, but its more likely I’ll just stitch words together here and let them drift.

Signing off with the window open and the hope for a thunderstorm to roll in and rattle the bones of the house.

Until later, dear journal.

Day 20,632

Runes and i ching robot, v0.2 , still building interpretation code for blog.

Output should include rune & i Ching, possibly a one line summary.

May merge in the tarot too?

import tkinter as tk
import random
from datetime import datetime

# Elder Futhark Runes with meanings
runes = [
    (“Fehu”, “Wealth, prosperity”),
    (“Uruz”, “Strength, health”),
    (“Thurisaz”, “Conflict, protection”),
    (“Ansuz”, “Communication, insight”),
    (“Raidho”, “Journey, travel”),
    (“Kenaz”, “Knowledge, creativity”),
    (“Gebo”, “Gift, generosity”),
    (“Wunjo”, “Joy, harmony”),
    (“Hagalaz”, “Disruption, hail”),
    (“Nauthiz”, “Need, resistance”),
    (“Isa”, “Stillness, ice”),
    (“Jera”, “Harvest, reward”),
    (“Eihwaz”, “Endurance, transformation”),
    (“Perthro”, “Mystery, fate”),
    (“Algiz”, “Protection, higher self”),
    (“Sowilo”, “Success, vitality”),
    (“Tiwaz”, “Justice, leadership”),
    (“Berkano”, “Birth, growth”),
    (“Ehwaz”, “Movement, change”),
    (“Mannaz”, “Humanity, cooperation”),
    (“Laguz”, “Flow, intuition”),
    (“Ingwaz”, “Fertility, potential”),
    (“Dagaz”, “Breakthrough, awakening”),
    (“Othala”, “Heritage, inheritance”)
]

# I Ching full 64 hexagrams
hexagrams = {
    “111111”: (1, “Creative Force”),
    “000000”: (2, “Receptive Earth”),
    “100010”: (3, “Difficulty at the Beginning”),
    “010001”: (4, “Youthful Folly”),
    “111010”: (5, “Waiting”),
    “010111”: (6, “Conflict”),
    “010000”: (7, “The Army”),
    “000010”: (8, “Holding Together”),
    “111011”: (9, “Taming the Power of the Small”),
    “110111”: (10, “Treading”),
    “111000”: (11, “Peace”),
    “000111”: (12, “Standstill”),
    “101111”: (13, “Fellowship with Men”),
    “111101”: (14, “Great Possession”),
    “001000”: (15, “Modesty”),
    “000100”: (16, “Enthusiasm”),
    “100110”: (17, “Following”),
    “011001”: (18, “Work on the Decayed”),
    “110000”: (19, “Approach”),
    “000011”: (20, “Contemplation”),
    “100101”: (21, “Biting Through”),
    “101001”: (22, “Grace”),
    “000001”: (23, “Splitting Apart”),
    “100000”: (24, “Return”),
    “100111”: (25, “Innocence”),
    “111001”: (26, “Great Taming”),
    “100001”: (27, “Nourishment”),
    “011110”: (28, “Great Exceeding”),
    “010010”: (29, “Danger”),
    “101101”: (30, “Clinging Fire”),
    “001110”: (31, “Influence”),
    “011100”: (32, “Endurance”),
    “001111”: (33, “Retreat”),
    “111100”: (34, “Great Power”),
    “000101”: (35, “Progress”),
    “101000”: (36, “Darkening of the Light”),
    “101011”: (37, “Family”),
    “110101”: (38, “Opposition”),
    “001010”: (39, “Obstruction”),
    “010100”: (40, “Deliverance”),
    “110001”: (41, “Decrease”),
    “100011”: (42, “Increase”),
    “111110”: (43, “Breakthrough”),
    “011111”: (44, “Coming to Meet”),
    “000110”: (45, “Gathering Together”),
    “011000”: (46, “Pushing Upward”),
    “010110”: (47, “Oppression”),
    “011010”: (48, “The Well”),
    “101110”: (49, “Revolution”),
    “011101”: (50, “The Cauldron”),
    “100100”: (51, “The Arousing”),
    “001001”: (52, “Keeping Still”),
    “001011”: (53, “Gradual Progress”),
    “110100”: (54, “Marrying Maiden”),
    “101100”: (55, “Abundance”),
    “001101”: (56, “The Wanderer”),
    “011011”: (57, “Gentle Wind”),
    “110110”: (58, “Joyous Lake”),
    “010011”: (59, “Dispersion”),
    “110010”: (60, “Limitation”),
    “110011”: (61, “Inner Truth”),
    “001100”: (62, “Small Exceeding”),
    “101010”: (63, “After Completion”),
    “010101”: (64, “Before Completion”)
}

def cast_runes():
    non_reversing = {“Gebo”, “Hagalaz”, “Isa”, “Jera”, “Sowilo”, “Dagaz”, “Ingwaz”}
    chosen = random.sample(runes, 3)
    result = []
    for name, meaning in chosen:
        if name in non_reversing:
            result.append((name, meaning))
        else:
            reversed_flag = random.choice([True, False])
            if reversed_flag:
                result.append((f”{name} (reversed)”, f”Blocked or inverted: {meaning}”))
            else:
                result.append((name, meaning))
    return result

def cast_i_ching():
    lines = []
    binary = “”
    for _ in range(6):
        tosses = [random.choice([2, 3]) for _ in range(3)]
        total = sum(tosses)
        if total == 6:
            lines.append(“Old Yin (6) – changing to Yang”)
            binary = “0” + binary
        elif total == 7:
            lines.append(“Young Yang (7)”)
            binary = “1” + binary
        elif total == 8:
            lines.append(“Young Yin (8)”)
            binary = “0” + binary
        elif total == 9:
            lines.append(“Old Yang (9) – changing to Yin”)
            binary = “1” + binary
    hex_info = hexagrams.get(binary, (“?”, “Unknown Hexagram”))
    return lines[::-1], hex_info

def days_since_birth():
    return (datetime.today() – datetime(1969, 2, 2)).days

def cast_all():
    rune_results = cast_runes()
    i_ching_lines, (hex_num, hex_name) = cast_i_ching()
    days = days_since_birth()

    output_text = “Runes Drawn:\n”
    for i, (name, meaning) in enumerate(rune_results, 1):
        output_text += f” {i}. {name} – {meaning}\n”

    output_text += “\nI Ching Hexagram (bottom to top):\n”
    for line in i_ching_lines:
        output_text += f” – {line}\n”
    output_text += f”\nHexagram #{hex_num}: {hex_name}\n”
    output_text += f”\nDays since Feb 2, 1969: {days} days”

    output.delete(“1.0”, tk.END)
    output.insert(tk.END, output_text)
    cast_all.result_text = output_text

def share_result():
    try:
        root.clipboard_clear()
        root.clipboard_append(cast_all.result_text)
        root.update()
        status_label.config(text=”Copied to clipboard!”)
    except:
        status_label.config(text=”Copy failed”)

# GUI setup (night mode)
root = tk.Tk()
root.title(“Runes & I Ching”)
root.configure(bg=”#1a1a1a”)
root.geometry(“380×640”)

title = tk.Label(root, text=”Rune & I Ching Caster”, font=(“Helvetica”, 16, “bold”), bg=”#1a1a1a”, fg=”white”)
title.pack(pady=10)

cast_button = tk.Button(root, text=”Cast Runes + I Ching”, command=cast_all, font=(“Helvetica”, 13),
                        bg=”#333″, fg=”white”)
cast_button.pack(pady=5)

share_button = tk.Button(root, text=”Share Results”, command=share_result, font=(“Helvetica”, 13),
                         bg=”#555″, fg=”white”)
share_button.pack(pady=5)

output = tk.Text(root, height=26, width=44, font=(“Courier”, 10), wrap=”word”,
                 bg=”#121212″, fg=”#dddddd”, insertbackground=”white”)
output.pack(padx=10, pady=10)

status_label = tk.Label(root, text=””, font=(“Helvetica”, 10), bg=”#1a1a1a”, fg=”#00cc99″)
status_label.pack()

cast_all.result_text = “”

root.mainloop()

Runes cast module fix

Some runes cannot be reversed

Gebo (ᚷ)
Hagalaz (ᚺ)
Isa (ᛁ)
Jera (ᛃ)
Sowilo (ᛋ)
Dagaz (ᛞ)
Ingwaz (ᛜ)

So the fixed cast_runes code is –

def cast_runes():
    non_reversing = {“Gebo”, “Hagalaz”, “Isa”, “Jera”, “Sowilo”, “Dagaz”, “Ingwaz”}
    chosen = random.sample(runes, 3)
    result = []
    for name, meaning in chosen:
        if name in non_reversing:
            result.append((name, meaning))
        else:
            reversed_flag = random.choice([True, False])
            if reversed_flag:
                result.append((f”{name} (reversed)”, f”Blocked or inverted: {meaning}”))
            else:
                result.append((name, meaning))
    return result

streaming Netflix in HD for 4 hours uses approximately 200 liters of water. This figure includes the water used in data centers to cool servers and in the production of the electricity used to power those servers

https://energy.mit.edu/news/how-can-you-reduce-the-environmental-impact-of-your-next-virtual-meeting/#:~:text=One%20hour%20of%20streaming%20or,size%20of%20an%20iPad%20Mini.

Texas ai is a mess too

https://techiegamers.com/texas-data-centers-quietly-draining-water/

Tuesday in a Minor Key

Clouds hung low over Catawba, like forgotten curtains in a theater that only stages quiet moments. The day unfurled at a thoughtful pace, no rush, no roar. Breakfast of maple oatmeal was good. Reliable. Like a friend who doesn’t ask questions but always shows up.

Working a bit more on the scrying app.  Glyphs rotate with slow intent, echoing Appalachian sigils that seem more felt than seen. The code behaved, mostly, as if the machine sensed it was being part of something more poetic than practical. There’s a rhythm in spinning shapes that speaks to something older than syntax.

Outside, nature offered scattered commentary: crows debating, trees nodding, humidity wrapping everything like a soft quilt. No omens, just ambiance.

Ended the day tangled in thought, wondering whether folklore knows it’s being reimagined daily. Probably doesn’t mind.

Tarot card in pydroid, 3 draw and celtic cross

import random

# === TAROT DECK DEFINITIONS ===

major_arcana = {
    “The Fool”: (“Beginnings, innocence, spontaneity”, “Recklessness, naivety”),
    “The Magician”: (“Manifestation, resourcefulness”, “Manipulation, deception”),
    “The High Priestess”: (“Intuition, mystery”, “Hidden motives, ignoring intuition”),
    “The Empress”: (“Fertility, nurturing”, “Dependency, creative blocks”),
    “The Emperor”: (“Authority, structure”, “Tyranny, rigidity”),
    “The Hierophant”: (“Tradition, learning”, “Rebellion, nonconformity”),
    “The Lovers”: (“Love, harmony, union”, “Disharmony, imbalance”),
    “The Chariot”: (“Willpower, victory”, “Lack of direction”),
    “Strength”: (“Courage, compassion”, “Doubt, insecurity”),
    “The Hermit”: (“Introspection, solitude”, “Isolation, withdrawal”),
    “Wheel of Fortune”: (“Luck, destiny”, “Resistance to change”),
    “Justice”: (“Truth, fairness”, “Injustice, dishonesty”),
    “The Hanged Man”: (“Letting go, perspective”, “Stalling, martyrdom”),
    “Death”: (“Endings, transformation”, “Resistance to change”),
    “Temperance”: (“Balance, moderation”, “Excess, imbalance”),
    “The Devil”: (“Addiction, materialism”, “Freedom, release”),
    “The Tower”: (“Sudden change, upheaval”, “Avoiding disaster”),
    “The Star”: (“Hope, renewal”, “Despair, lack of faith”),
    “The Moon”: (“Illusion, intuition”, “Confusion, clarity”),
    “The Sun”: (“Joy, success”, “Negativity, sadness”),
    “Judgement”: (“Reflection, rebirth”, “Guilt, refusal to change”),
    “The World”: (“Completion, achievement”, “Lack of closure”)
}

suits = {
    “Cups”: “Emotions, relationships”,
    “Pentacles”: “Material, work, finances”,
    “Swords”: “Thought, conflict, logic”,
    “Wands”: “Action, creativity, passion”
}

ranks = {
    “Ace”: (“New beginnings in”, “Blocked energy in”),
    “Two”: (“Balance and partnership in”, “Imbalance and indecision in”),
    “Three”: (“Growth and collaboration in”, “Miscommunication or delay in”),
    “Four”: (“Stability and rest in”, “Stagnation or boredom in”),
    “Five”: (“Conflict and change in”, “Recovery or resolution in”),
    “Six”: (“Harmony and support in”, “Lack of help or imbalance in”),
    “Seven”: (“Challenges and perseverance in”, “Giving up or overwhelm in”),
    “Eight”: (“Movement and focus in”, “Distraction or lack of direction in”),
    “Nine”: (“Fulfillment and satisfaction in”, “Overindulgence or dissatisfaction in”),
    “Ten”: (“Completion and legacy in”, “Burden or burnout in”),
    “Page”: (“Curiosity and new ideas in”, “Immaturity or distraction in”),
    “Knight”: (“Action and pursuit in”, “Recklessness or inaction in”),
    “Queen”: (“Maturity and nurturing in”, “Coldness or dependence in”),
    “King”: (“Mastery and leadership in”, “Control issues or arrogance in”)
}

# === DECK CREATION ===

def build_tarot_deck():
    deck = {}
    for name, meanings in major_arcana.items():
        deck[name] = {“upright”: meanings[0], “reversed”: meanings[1]}
    for suit, theme in suits.items():
        for rank, meanings in ranks.items():
            card = f”{rank} of {suit}”
            up = f”{meanings[0]} {theme.lower()}”
            rev = f”{meanings[1]} {theme.lower()}”
            deck[card] = {“upright”: up, “reversed”: rev}
    return deck

def draw_card(deck):
    card = random.choice(list(deck.keys()))
    is_rev = random.choice([True, False])
    orientation = “Reversed” if is_rev else “Upright”
    meaning = deck[card][“reversed” if is_rev else “upright”]
    return card, orientation, meaning

# === FORMATTING OPTIONS ===

def format_plain(title, entries):
    out = f”{title}\n\n”
    for label, card, orient, meaning in entries:
        out += f”{label}: {card} ({orient})\nMeaning: {meaning}\n\n”
    return out.strip()

def format_blog(title, entries):
    out = f”## {title}\n\n”
    for label, card, orient, meaning in entries:
        out += f”**{label}: {card}** *({orient})*\n→ {meaning}\n\n”
    return out.strip()

def format_bluesky(title, entries):
    lines = [f”{title} 🔮”]
    for label, card, orient, meaning in entries:
        short = meaning.split(“,”)[0].strip()
        emoji = “🌞” if orient == “Upright” else “🌒”
        lines.append(f”{label}: {card} {emoji} — {short}”)
    lines.append(“#Tarot #Divination #CelticCross” if “Celtic” in title else “#TarotReading #3CardSpread”)
    return “\n”.join(lines)

def share_output(title, entries):
    print(“\nChoose format:”)
    print(“1. Plain”)
    print(“2. Blog”)
    print(“3. Bluesky”)
    style = input(“Select (1–3): “).strip()

    if style == “2”:
        output = format_blog(title, entries)
    elif style == “3”:
        output = format_bluesky(title, entries)
    else:
        output = format_plain(title, entries)

    print(“\n>>> COPY BELOW >>>\n”)
    print(output)
    print(“\n<<< END <<<“)

# === SPREADS ===

def three_card_spread(deck):
    labels = [“Past”, “Present”, “Future”]
    entries = []
    for label in labels:
        card, orient, meaning = draw_card(deck)
        entries.append((label, card, orient, meaning))
    share_output(“3-Card Tarot Spread”, entries)

def celtic_cross_spread(deck):
    positions = [
        “1. Present Situation”,
        “2. Immediate Challenge”,
        “3. Subconscious Influence”,
        “4. Past Influence”,
        “5. Conscious Goal”,
        “6. Near Future”,
        “7. Self / Attitude”,
        “8. Environment”,
        “9. Hopes & Fears”,
        “10. Final Outcome”
    ]
    used = set()
    entries = []
    for label in positions:
        while True:
            card, orient, meaning = draw_card(deck)
            if card not in used:
                used.add(card)
                entries.append((label, card, orient, meaning))
                break
    share_output(“Celtic Cross Spread”, entries)

# === MAIN ===

def main():
    tarot = build_tarot_deck()
    print(“=== Tarot Divination ===”)
    print(“1. 3-Card Spread”)
    print(“2. Celtic Cross Spread”)
    choice = input(“Choose your spread (1 or 2): “).strip()
    if choice == “1”:
        three_card_spread(tarot)
    elif choice == “2”:
        celtic_cross_spread(tarot)
    else:
        print(“Invalid input. Try again.”)

if __name__ == “__main__”:
    main()

Robot scry

ᚺ Hagalaz 🌩️ – disruption
ᛜ Ingwaz (rev) 🚫🌱 – blocked potential
ᛖ Ehwaz 🐎 – movement, change
☯️ I Ching: Hex 11 Peace 🕊️
1 changing line: ⚊ → ⚋ (force yields)

A storm breaks, growth stirs beneath stillness. The horse moves. Peace arrives through softening.


ᚺ Hagalaz 🌩️ – the sky throws ice.
Not cruelty—just change, fast and loud.
Sometimes the only way forward is a crack in the routine.
The storm doesn’t ask. It arrives.


ᛜ Ingwaz (rev) 🚫🌱 – the seed sleeps.
Not dead, just deep.
A pause. A waiting womb.
Potential hides where eyes don’t go.
You can’t force spring in winter, but the root still dreams.


ᛖ Ehwaz 🐎 – hooves in the mist.
The call to move, even if only inside.
New ground ahead. Old ground behind.
Trust the rhythm. Forward isn’t always fast, but it’s real.


☯️ I Ching – Hex 11: Peace 🕊️
⚊→⚋ – strength steps aside.
Heaven below, Earth above—balance flips.
Not stillness, but harmony.
Peace isn’t quiet. It’s everything humming in tune.

Storm, seed, stride, surrender.

Day 20,630

Had one of those mornings where the light hit just right, gold filtering through the blinds, casting lines across the floor like quiet Morse code. The cat followed the sunbeam from room to room, eventually curling up on my arm while I tried to write. Productivity: paused, but heart: full.

The neighborhood’s been especially green after last week’s rain. That stretch between 4th and Main is nearly overgrown now, the kudzu creeping like it’s got a plan. I kind of like it, honestly. There’s something comforting about nature pushing back a little. Spotted three rabbits by the empty lot behind the old laundromat. They didn’t seem too concerned with me, just nibbling and blinking in that deliberate bunny way.

Enjoyed a breakfast with my sweetheart of splitting a chocolate scone and london fog pastry. Not life-changing, but pleasant. A soft sweetness with a little tart bite, like late summer should be. Swung by CVS to get my meds and the older gentleman who plays harmonica near the benches was out again, he always finishes with Shenandoah and tips his hat like he’s closing a show. It gets me every time.

Back home, I sorted through some of my old notebooks ; little scribbled ideas, half-formed stories, sketches of bears in top hats, and robots with coffee mugs. There’s a kind of comfort in seeing your past self try. Like looking at your own roots.

Anyway, not much else to report… just a soft day, in a soft season. I’ll take it.

Be well, stay kind, and if you pass by the harmonica man, drop a quarter for me.

Until later, dear journal.

Drawing of a bunny snacking on clover

Welcome to my wall scrawls.