initial commit, nothing much here

.gitignore

@@ -0,0 +1,2 @@
+.vscode/
+sphere_grid.egg-info

README.md

@@ -0,0 +1,12 @@
+# Roadmap ideas
+
+- [ ] seeded RNG
+- [ ] pattern: circle, line
+
+# Tools
+
+https://www.pythonguis.com/tutorials/pyqt6-qgraphics-vector-graphics/
+
+# About FFX sphere grid design
+
+http://whats-in-a-game.com/ffx-sphere-grid-analysis/

grid/sphere/cell.py

@@ -0,0 +1,22 @@
+class Cell:
+
+    MIN_NEIGHBORS = 1
+    MAX_NEIGHBORS = 4
+
+    def __init__(self) -> None:
+        self.neighbors = []
+
+    def add_neightbor(self, new_neighbor: 'Cell'):
+        self.neighbors.append(new_neighbor)
+
+    def __str__(self) -> str:
+        return "o"
+
+class StatSphere(Cell):
+
+    pass
+
+class StrengthSphere(StatSphere):
+    
+    def __init__(self) -> None:
+        super().__init__()

grid/sphere/grid.py

@@ -0,0 +1,28 @@
+from random import choice, randint
+
+from grid.sphere.cell import Cell
+
+class Grid():
+
+    def __init__(self) -> None:
+        self.start = None
+
+    def set_start(self, cell: Cell):
+        self.start = cell
+
+    @classmethod
+    def generate_grid(cls, sphere_number: int=10) -> 'Grid':
+        # pick an impl type instead
+        starting_point = Cell()
+        cls.generate_neighbors(starting_point, sphere_number)
+        grid = cls()
+        grid.set_start(starting_point)
+        return grid
+
+    @classmethod
+    def generate_neighbors(cls, current_cell: Cell, remaining_cells: int) -> Cell:
+        number_of_neighbor = randint(Cell.MIN_NEIGHBORS, Cell.MAX_NEIGHBORS)
+        for _ in number_of_neighbor:
+            current_cell.add_neightbor(Cell())
+        remaining_cells = max(0, remaining_cells-number_of_neighbor)
+        return choice(current_cell.neighbors)

grid/ui/light.py

@@ -0,0 +1,117 @@
+# Copyright (C) 2010 velociraptor Genjix <aphidia@hotmail.com>
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import sys
+
+from PySide6.QtCore import QTimer, Qt, Property, Slot
+from PySide6.QtGui import QPainter, QPalette
+from PySide6.QtWidgets import QApplication, QVBoxLayout, QWidget
+from PySide6.QtStateMachine import QFinalState, QState, QStateMachine
+
+
+class LightWidget(QWidget):
+    def __init__(self, color):
+        super().__init__()
+        self.color = color
+        self._on_val = False
+
+    def is_on(self):
+        return self._on_val
+
+    def set_on(self, on):
+        if self._on_val == on:
+            return
+        self._on_val = on
+        self.update()
+
+    @Slot()
+    def turn_off(self):
+        self.set_on(False)
+
+    @Slot()
+    def turn_on(self):
+        self.set_on(True)
+
+    def paintEvent(self, e):
+        if not self._on_val:
+            return
+        with QPainter(self) as painter:
+            painter.setRenderHint(QPainter.Antialiasing)
+            painter.setBrush(self.color)
+            painter.drawEllipse(0, 0, self.width(), self.height())
+
+    on = Property(bool, is_on, set_on)
+
+
+class TrafficLightWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        vbox = QVBoxLayout(self)
+        self._red_light = LightWidget(Qt.red)
+        vbox.addWidget(self._red_light)
+        self._yellow_light = LightWidget(Qt.yellow)
+        vbox.addWidget(self._yellow_light)
+        self._green_light = LightWidget(Qt.green)
+        vbox.addWidget(self._green_light)
+        pal = QPalette()
+        pal.setColor(QPalette.Window, Qt.black)
+        self.setPalette(pal)
+        self.setAutoFillBackground(True)
+
+
+def create_light_state(light, duration, parent=None):
+    light_state = QState(parent)
+    timer = QTimer(light_state)
+    timer.setInterval(duration)
+    timer.setSingleShot(True)
+    timing = QState(light_state)
+    timing.entered.connect(light.turn_on)
+    timing.entered.connect(timer.start)
+    timing.exited.connect(light.turn_off)
+    done = QFinalState(light_state)
+    timing.addTransition(timer.timeout, done)
+    light_state.setInitialState(timing)
+    return light_state
+
+
+class TrafficLight(QWidget):
+    def __init__(self):
+        super().__init__()
+        vbox = QVBoxLayout(self)
+        widget = TrafficLightWidget()
+        vbox.addWidget(widget)
+        vbox.setContentsMargins(0, 0, 0, 0)
+
+        machine = QStateMachine(self)
+        red_going_yellow = create_light_state(widget._red_light, 1000)
+        red_going_yellow.setObjectName('redGoingYellow')
+        yellow_going_green = create_light_state(widget._red_light, 1000)
+        yellow_going_green.setObjectName('yellowGoingGreen')
+        red_going_yellow.addTransition(red_going_yellow.finished,
+                                       yellow_going_green)
+        green_going_yellow = create_light_state(widget._yellow_light, 3000)
+        green_going_yellow.setObjectName('greenGoingYellow')
+        yellow_going_green.addTransition(yellow_going_green.finished,
+                                         green_going_yellow)
+        yellow_going_red = create_light_state(widget._green_light, 1000)
+        yellow_going_red.setObjectName('yellowGoingRed')
+        green_going_yellow.addTransition(green_going_yellow.finished,
+                                         yellow_going_red)
+        yellow_going_red.addTransition(yellow_going_red.finished,
+                                       red_going_yellow)
+
+        machine.addState(red_going_yellow)
+        machine.addState(yellow_going_green)
+        machine.addState(green_going_yellow)
+        machine.addState(yellow_going_red)
+        machine.setInitialState(red_going_yellow)
+        machine.start()
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    widget = TrafficLight()
+    widget.resize(110, 300)
+    widget.show()
+    sys.exit(app.exec())

grid/ui/sphere_widget.py

@@ -0,0 +1,15 @@
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QPaintEvent, QPainter, QPalette
+from PySide6.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+class SphereWidget(QWidget):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        with QPainter(self) as painter:
+            painter.setRenderHint(QPainter.Antialiasing)
+            painter.setBrush(Qt.red)
+            painter.drawEllipse(0, 0, self.width(), self.height())
+        return super().paintEvent(event)

grid/ui/window.py

@@ -0,0 +1,64 @@
+import sys
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QBrush, QPainter, QPen
+from PySide6.QtWidgets import (
+    QApplication,
+    QGraphicsEllipseItem,
+    QGraphicsRectItem,
+    QGraphicsScene,
+    QGraphicsView,
+    QHBoxLayout,
+    QVBoxLayout,
+    QWidget,
+)
+
+class Window(QWidget):
+    def __init__(self):
+        super().__init__()
+
+        # Defining a scene rect of 400x200, with it's origin at 0,0.
+        # If we don't set this on creation, we can set it later with .setSceneRect
+        self.scene = QGraphicsScene(0, 0, 600, 400)
+
+        for i in range(5):
+            # Draw a rectangle item, setting the dimensions.
+            rect = QGraphicsRectItem(0, 0, 200, 50)
+            rect.setPos(50+i*10, 20+ i*20)
+            brush = QBrush(Qt.GlobalColor.red)
+            rect.setBrush(brush)
+            # Define the pen (line)
+            pen = QPen(Qt.GlobalColor.cyan)
+            pen.setWidth(10)
+            rect.setPen(pen)
+            self.scene.addItem(rect)
+
+        ellipse = QGraphicsEllipseItem(0, 0, 100, 100)
+        ellipse.setPos(75, 30)
+        brush = QBrush(Qt.GlobalColor.blue)
+        ellipse.setBrush(brush)
+        pen = QPen(Qt.GlobalColor.green)
+        pen.setWidth(5)
+        ellipse.setPen(pen)
+
+        # Add the items to the scene. Items are stacked in the order they are added.
+        self.scene.addItem(ellipse)
+
+        # Define our layout.
+        hbox = QHBoxLayout()
+
+        view = QGraphicsView(self.scene)
+        view.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        vbox = QHBoxLayout(self)
+        vbox.addLayout(hbox)
+        vbox.addWidget(view)
+
+        self.setLayout(vbox)
+
+app = QApplication(sys.argv)
+
+w = Window()
+w.show()
+
+app.exec()

requirements.txt

@@ -0,0 +1 @@
+pyside6==6.6.1

setup.py

@@ -0,0 +1,8 @@
+from setuptools import setup, find_packages
+
+
+setup(
+    name="sphere_grid",
+    version="1.0",
+    packages=find_packages("."),
+)