hashhub/hashengine.py

import tkinter as tk
import string
import random

class stdrend:
    def __init__(self, size):
        self._size = size
        self._grid = {}
        self._win = tk.Tk()
        for y in range(size[1]):
            for x in range(size[0]):
                temp = tk.Label(text=" ")
                temp.grid(row=y, column=x)
                self._win.update()
                self._grid[f"{x}:{y}"] = temp

    def coltohex(self, target):
        colors = []
        target = [target.r, target.g, target.b]
        for i in target:
            colors.append(("0"*(2-len(hex(i)[2:])))+hex(i)[2:])
        out = ""
        for i in colors:
            out = out + i
        return "#"+out

    def pix(self, x, y, text, bcolor, fcolor):
        if f"{x}:{y}" in self._grid:
            self._grid[f"{x}:{y}"].config(text=text, bg=self.coltohex(bcolor), fg=self.coltohex(fcolor))
            self._win.update()

class color3:
    def __init__(self, r=0, g=0, b=0):
        self.r = r
        self.g = g
        self.b = b

    def __add__(self, v):
        temp = color3(self.r+v.r, self.g+v.g, self.b+v.b)
        temp.r = temp.r%255
        temp.g = temp.g%255
        temp.b = temp.b%255
        return temp
    
    def __sub__(self, v):
        temp = color3(self.r-v.r, self.g-v.g, self.b-v.b)
        temp.r = temp.r%255
        temp.g = temp.g%255
        temp.b = temp.b%255
        return temp
    
    def __mul__(self, v):
        temp = color3(self.r*v.r, self.g*v.g, self.b*v.b)
        temp.r = temp.r%255
        temp.g = temp.g%255
        temp.b = temp.b%255
        return temp
    
    def __iadd__(self, v):
        temp = color3(self.r+v.r, self.g+v.g, self.b+v.b)
        temp.r = temp.r%255
        temp.g = temp.g%255
        temp.b = temp.b%255
        return temp
    
    def __isub__(self, v):
        temp = color3(self.r-v.r, self.g-v.g, self.b-v.b)
        temp.r = temp.r%255
        temp.g = temp.g%255
        temp.b = temp.b%255
        return temp
    
    def __imul__(self, v):
        temp = color3(self.r*v.r, self.g*v.g, self.b*v.b)
        temp.r = temp.r%255
        temp.g = temp.g%255
        temp.b = temp.b%255
        return temp

class vector2:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    
    def __add__(self, v):
        return vector2(self.x+v.x, self.y+v.y)
    
    def __sub__(self, v):
        return vector2(self.x-v.x, self.y-v.y)
    
    def __mul__(self, v):
        return vector2(self.x*v.x, self.y*v.y)
    
    def __iadd__(self, v):
        return vector2(self.x+v.x, self.y+v.y)
    
    def __isub__(self, v):
        return vector2(self.x-v.x, self.y-v.y)
    
    def __imul__(self, v):
        return vector2(self.x*v.x, self.y*v.y)

class NULL:
    def __init__(self):
        return None

class enum:
    def __init__(self, sel):
        self._sel = dict(sel)
        for i in self._sel:
            setattr(self, i, self._sel[i])
    
    def getposssel(self):
        return list(self._sel.keys())

cammode = enum({"editable": 0, "follow": 1})

class obj:
    def __init__(self):
        self.position = vector2()
        self.char = " "
        self.ID = 0
        self.gravity = 0
        self.acceleration = vector2()
        self.velocity = vector2()
        self.friction = 0
        self.collide = True
        self.touch = True
        self.anchored = False
        self.bcolor = color3(255, 255, 255)
        self.fcolor = color3()

class camera(obj):
    def __init__(self):
        super().__init__()
        self.mode = cammode.editable
        self.subject = None
        self.collide = False
        self.touch = False
        self.char = " "
    
    def update(self):
        if self.mode == cammode.follow and self.subject:
            self.position = self.subject.position

class game:
    def __init__(self, size=[10, 10], renderer=stdrend):
        if renderer == None: raise TypeError("Renderer class needed!")
        self._size = size
        self._renderer = renderer(size)
        self._objects = {}
        self.camera = camera()

    def addobj(self, obj):
        id = ""
        for i in range(256):
            id = id + random.choice(list(string.ascii_letters))
        obj.ID = id
        self._objects[id] =  obj
    
    def removeobj(self, obj):
        self._objects.pop(obj.ID)
        obj.ID = NULL()

    def removeobjbyid(self, id):
        self._objects.pop(id).ID = NULL()

    def between(self, min, max, target):
        if min < target < max: return True
        return False

    def render(self):
        for i in list(self._objects.values()):
            pos = i.position + self.camera.position
            if not self.between(-1, self._size[0], pos.x) or not self.between(-1, self._size[1], pos.y): continue
            self._renderer.pix(pos.x, pos.y, i.char, i.bcolor, i.fcolor)

if __name__ == "__main__":
    testgame = game()
    for i in range(10):
        for f in range(10):
            object = obj()
            object.char = "#"
            object.position = vector2(i, f)
            object.bcolor = color3()
            testgame.addobj(object)
    testgame.render()
    print(object.ID)
    while True:
        for i in testgame._objects:
            testgame._objects[i].fcolor += color3(1, 11, 111)
            testgame._objects[i].bcolor += color3(1, 11, 111)
        testgame.render()