basic system done

HEMD.py

@@ -6,6 +6,15 @@ class color3:
         self.g = g
         self.b = b
 
+    def __maxnum__(self, target, maxn):
+        return "0"*(maxn-len(target))+target
+
+    def __tohex__(self):
+        r = self.__maxnum__(hex(self.r)[2:], 2)
+        g = self.__maxnum__(hex(self.g)[2:], 2)
+        b = self.__maxnum__(hex(self.b)[2:], 2)
+        return "#"+r+g+b
+
     def _add(self,v):
         temp = color3(self.r+v.r, self.g+v.g, self.b+v.b)
         temp.r = temp.r%255
@@ -28,28 +37,31 @@ class color3:
         return temp
 
     def __add__(self, v):
-        self._add(v)
+        return self._add(v)
     
     def __sub__(self, v):
-        self._sub(v)
+        return self._sub(v)
     
     def __mul__(self, v):
-        self._mul(v)
+        return self._mul(v)
     
     def __iadd__(self, v):
-        self._add(v)
+        return self._add(v)
     
     def __isub__(self, v):
-        self._sub(v)
+        return self._sub(v)
     
     def __imul__(self, v):
-        self._mul(v)
+        return self._mul(v)
 
 class vector2:
     def __init__(self, x=0, y=0):
         self.x = x
         self.y = y
 
+    def __copy__(self):
+        return vector2(self.x, self.y)
+
     def __round__(self):
         return vector2(round(self.x), round(self.y))
 
@@ -98,7 +110,3 @@ class event:
 
     def attach(self, target):
         self._attached.append(target)
-
-class sprite:
-    def __init__(self):
-        pass

hashengine.py

@@ -1,8 +1,9 @@
 import mtTkinter as tk
-from HEMD import color3, vector2, event, enum, NULL, sprite
+from HEMD import color3, vector2, event, enum, NULL
 import random
 import string
 import math
+import time
 #import itertools
 #import multiprocessing
 
@@ -17,21 +18,26 @@ class obj:
         self.anchored = True
         self.velocity = vector2()
         self.acceleration = vector2()
-        self.sprite = sprite()
         self.id = NULL()
         self.color = color3()
         self.colliding = event()
         self.parent = NULL()
         self.children = []
+        self.ignorecollision = []
 
 class game:
-    def __init__(self, canvas: tk.Canvas):
+    def __init__(self, canvas: tk.Canvas, pixelsize=3):
         self._canvas = canvas
-        self._height = int(canvas.winfo_reqheight()/3)
-        self._width = int(canvas.winfo_reqwidth()/3)
+        self._height = int(canvas.winfo_reqheight()/pixelsize)
+        self._width = int(canvas.winfo_reqwidth()/pixelsize)
+        self._pixelsize = pixelsize
         self._OAP = {}
+        self._PAO = {}
         self._objects = {}
         self._visobjects = {}
+        self._camera = obj()
+        self._camera.position = vector2()
+        self._camera.zoom = pixelsize
         """self._workers = []
         self._processes = 2 # total number of processes.
         for i in range(self._processes):
@@ -41,7 +47,7 @@ class game:
 
             temp = multiprocessing.Process()
             temp.start()
-            self._workers.append({"process": temp, ""})""" # scraped idea im keeping it in incase i ever decide to use it
+            self._workers.append({"process": temp, ""})""" # scraped idea, im keeping it in incase i ever decide to use it
 
     def genid(self):
         out = ""
@@ -49,20 +55,33 @@ class game:
             out = out + random.choice(list(string.ascii_letters))
         return out
 
+    def v2tuple(self, target: vector2):
+        return (target.x, target.y)
+    
+    def tuple2v(self, target: tuple):
+        return vector2(target[0], target[1])
+
     def addtooap(self, target: obj):
-        if target.position.__round__() in self._OAP:
-            self._OAP[target.position.__round__()].append(target)
+        if self.v2tuple(target.position.__round__()) in self._OAP:
+            self._OAP[self.v2tuple(target.position.__round__())].append(target)
         else:
-            self._OAP[target.position.__round__()] = [target]
+            self._OAP[self.v2tuple(target.position.__round__())] = [target]
+
+    def updateobjinoap(self, target: obj):
+        self.remfromoap(target)
+        self.addtooap(target)
 
     def remfromoap(self, target: obj):
-        self._OAP[target.position.__round__()].remove(target)
-        if len(self._OAP[target.position.__round__()]) == 0:
-            self._OAP.pop(target.position.__round__())
+        for i in self._OAP:
+            if target in self._OAP[i]:
+                self._OAP[i].remove(target)
+                if len(self._OAP[i]) == 0:
+                    self._OAP.pop(i)
+                break
 
     def getfromoap(self, target: vector2):
-        if target.__round__() in self._OAP:
-            return self._OAP[target.__round__()]
+        if self.v2tuple(target.__round__()) in self._OAP:
+            return self._OAP[self.v2tuple(target.__round__())]
         else:
             return []
 
@@ -70,6 +89,7 @@ class game:
         temp = self.genid()
         if physics: self._objects[temp] = target
         self._visobjects[temp] = target
+        target.id = temp
         self.addtooap(target)
     
     def removeobj(self, target: obj):
@@ -83,13 +103,76 @@ class game:
     def getcolliding(self, target):
         return self.getfromoap(target.position)
 
-    def calcphysobj(self):
-        raise NotImplementedError()
+    def handlecollision(self, obj1: obj, obj2: obj):
+        #False is blocked
+        #True is not blocked
+        #returns tuple like this (True, True)
+        xblock = False
+        yblock = False
+        obj1pos = obj1.position.__round__()
+        obj2pos = obj2.position.__round__()
+        if obj2.collide == False: return (xblock, yblock)
+        if obj2pos.x > obj1pos.x > obj2pos.x: xblock = True
+        if obj2pos.y > obj1pos.y > obj2pos.y: yblock = True
+        if obj2.anchored == True:
+            obj1.velocity = vector2()
+        else:
+            if xblock: obj1.velocity.x = obj1.velocity.x/2;obj2.velocity.x = obj2.velocity.x/2
+            if yblock: obj1.velocity.y = obj1.velocity.y/2;obj2.velocity.y = obj2.velocity.y/2
+        return (xblock, yblock)
+
+    def calcphysobj(self, target: obj):
+        if target.anchored: target.velocity=vector2();return
+        new = target.position + target.velocity
+        oldvel = target.velocity.__copy__()
+        if target.collide == True:
+            colliding = self.getfromoap(new)
+            if len(colliding) > 0: target.colliding.execute()
+            for i in colliding:
+                if i == target: continue
+                if i in target.ignorecollision or target in i.ignorecollision: continue
+                i.colliding.execute()
+                temp = self.handlecollision(target, i)
+                if temp[0] == False: target.position.x += oldvel.x
+                if temp[1] == False: target.position.y += oldvel.y
+            if len(colliding) == 0: target.position += target.velocity
+        else:
+            target.position += target.velocity
+        target.velocity += target.acceleration
+        self.updateobjinoap(target)
+
+    def render(self):
+        self._canvas.delete(tk.ALL)
+        self._height = int(canvas.winfo_reqheight()/self._camera.zoom)
+        self._width = int(canvas.winfo_reqwidth()/self._camera.zoom)
+        self._pixelsize = self._camera.zoom
+        for y in range(self._camera.position.y, self._height+self._camera.position.y):
+            for x in range(self._camera.position.y, self._width+self._camera.position.y):
+                obj = self.getfromoap(vector2(x, y))
+                if len(obj) == 0: continue
+                obj = obj[0]
+                self._canvas.create_rectangle(x*self._pixelsize, y*self._pixelsize, x*self._pixelsize+self._pixelsize, y*self._pixelsize+self._pixelsize, fill=obj.color.__tohex__(), width=0)
+
+    def updobjs(self):
+        for i in self._objects.values():
+            self.calcphysobj(i)
 
 if not "__CMD__" in globals():
     root = tk.Tk()
     canvas = tk.Canvas(root)
-    canvas.create_rectangle(50, 50, 53, 53, fill="#ff0000", width=0)
     canvas.grid()
     temp = game(canvas)
-    root.mainloop()
+    for i in range(200):
+        tempobj = obj()
+        tempobj.position = vector2(5, i)
+        tempobj.anchored = False
+        tempobj.collide = True
+        temp.addobj(tempobj)
+    while True:
+        temp.updobjs()
+        for i in temp._objects.values():
+            i.color += color3(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+            #i.position = vector2(random.randint(0, temp._width), random.randint(0, temp._height))
+        temp.render()
+        root.update()
+        time.sleep(0.1)

main.py

@@ -8,7 +8,7 @@ def loadfile(target):
 def execins(ins):
     print(f"\033[A> {ins}\r")
     try:
-        out = eval(ins, globals())
+        out = exec(ins, globals())
     except Exception as e:
         out = e
     if out != None: print(out)