angel-cpu 0.1__tar.gz

angel_cpu-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ERROR-Xmakernotfound
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

angel_cpu-0.1/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: angel-cpu
+Version: 0.1
+Summary: A CPU framework
+Home-page: 
+Author: ERROR-Xmakernotfound
+Author-email: 
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Hello!\
+Have you ever tried to make a cpu simulation but don't want to write 300+ lines of code?\
+Well then you don't have to anymore!\
+AngelCPU does most of the heavy lifting for you, so let's get started before I fall asleep while typing this.
+# Getting Started
+First lets install Angel
+```bash
+pip install angel-cpu
+```
+Now, let's start with some simple stuff,
+*give me a second i'm setting up*
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+```
+*Alright now i'm done setting up.*
+As you can see we have a class here
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")#THIS RIGHT HERE
+```
+Let's first set up the basic CPU ARCH
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+# no reset does NOT reset the ARCH's registers and ram it just resets the ARCH's PC and Program
+ARCH.reset()
+# The name of the Register doesn't matter go crazy if you want
+# The amount of Registers also don't matter, you can add like 50 of them and it wouldn't care
+ARCH.add_register("Rxa")
+ARCH.add_register("Rxb")
+ARCH.add_register("Rxc")
+ARCH.add_register("Rxe")
+# the size is calculated by the x (400) times the y (200)
+ARCH.add_ram(400,200)
+# 32 bit integer limit
+ARCH.set_max(0xffffffff)
+# we're setting the command symbol to be ; so it's like real ASM
+ARCH.set_comment_symbol(";")
+```
+*huff* that took me 30 minutes to write... (all of the time was because of the comments XD)\
+Anyway... let's go over what the eclipse is all of these before my head explodes
+
+`ARCH.reset()`
+
+Resets the ARCH's PC and Program
+
+`ARCH.add_register("Register name")`
+
+adds a register
+
+`ARCH.add_ram(400,200)`
+
+set's the ram size which with this one will be... *give me a sec i'm calculating...* 80000 cells... *WOW*
+
+`ARCH.set_max(0xffffffff)`
+
+sets the integer limit, I just put the 32 bit limit because it's the bare minimum *trust me with this, you are going to need **much** more than 4294967295 bits **trust me***
+
+`ARCH.set_comment_symbol(";")`
+
+This Sets the comment symbol, any line that starts with it will be ignored in the assembler.\
+
+Now that we got that covered it's time to add some opcodes so we can actually do stuff
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+# no reset does NOT reset the ARCH's registers and ram it just resets the ARCH's PC and Program
+ARCH.reset()
+# The name of the Register doesn't matter go crazy if you want
+# The amount of Registers also don't matter, you can add like 50 of them and it wouldn't care
+ARCH.add_register("Rxa")
+ARCH.add_register("Rxb")
+ARCH.add_register("Rxc")
+ARCH.add_register("Rxe")
+# the size is calculated by the x (400) times the y (200)
+ARCH.add_ram(400,200)
+# 32 bit integer limit
+ARCH.set_max(0xffffffff)
+# we're setting the command symbol to be ; so it's like real ASM
+ARCH.set_comment_symbol(";")
+def MOV(reg,value):
+    ARCH.set_register(reg,value)
+def LOG(txt):
+    if txt in ARCH.registers:
+        print(ARCH.registers[txt])
+    else:
+        print(txt)
+# It's important to note that when adding opcodes don't put parentheses on the function
+# ARCH.add_opcode(0x0,MOV()) <-- incorrect, paratheses arnt opposed to be in the opcodes 
+# ARCH.add_opcode(0x0,MOV) <-- correct
+ARCH.add_opcode(0x0,MOV)
+ARCH.add_opcode(0x1,LOG)
+c="""
+MOV Rxa 10
+LOG Rxa
+"""
+ARCH.assemble(c)
+ARCH.run()
+```
+Okay there's a lot of stuff here so let's talk about the things that changed
+
+`ARCH.add_opcode(hex_ID function)`
+
+This adds an opcode, and when adding the function, please, **do not add parentheses**
+
+`ARCH.assemble(code)`
+
+This assembles the code from ASM format into something that the CPU can actually understand, then it loads it into the CPU's program ready to run.
+
+`ARCH.run()`
+
+This takes the code from the Program and runs it, simple and very useful.
+
+Now let's talk about the ASM format
+```AngelASM
+MOV Rxa 10
+LOG Rxa
+```
+The command comes first, each argument comes after the command separated by spaces, but then you might be wondering, "what about strings with spaces in them?" well, strings are strings so there has to be these (") surrounding them, without that it wouldn't be a string!
+
+Alright this is taking a long time and **I'm** running out of time so I'll just give you a dump of the commands, you should be able to tell what they do...
+```ASM_helper
+add_regiser
+add_ram
+add_opcode
+add_intruction
+
+set_window_name
+set_max
+set_pc
+set_register
+set_ram
+reset
+set_comment_symbol
+
+get_register
+get_ram
+get_pc
+
+text
+wait
+scroll
+is_Mouse_Touching_Surface
+show_mouse
+quit
+frame
+load_pixels
+events
+clear
+clear_logs
+is_held
+render_surfaces
+add_surface
+add_pixel
+text_input
+mouse_down_on_group
+mouse_pos
+
+assemble
+
+run
+```
+*huff* alright, that's all of them....\
+that's it for now, bye!

angel_cpu-0.1/README.md

@@ -0,0 +1,165 @@
+Hello!\
+Have you ever tried to make a cpu simulation but don't want to write 300+ lines of code?\
+Well then you don't have to anymore!\
+AngelCPU does most of the heavy lifting for you, so let's get started before I fall asleep while typing this.
+# Getting Started
+First lets install Angel
+```bash
+pip install angel-cpu
+```
+Now, let's start with some simple stuff,
+*give me a second i'm setting up*
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+```
+*Alright now i'm done setting up.*
+As you can see we have a class here
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")#THIS RIGHT HERE
+```
+Let's first set up the basic CPU ARCH
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+# no reset does NOT reset the ARCH's registers and ram it just resets the ARCH's PC and Program
+ARCH.reset()
+# The name of the Register doesn't matter go crazy if you want
+# The amount of Registers also don't matter, you can add like 50 of them and it wouldn't care
+ARCH.add_register("Rxa")
+ARCH.add_register("Rxb")
+ARCH.add_register("Rxc")
+ARCH.add_register("Rxe")
+# the size is calculated by the x (400) times the y (200)
+ARCH.add_ram(400,200)
+# 32 bit integer limit
+ARCH.set_max(0xffffffff)
+# we're setting the command symbol to be ; so it's like real ASM
+ARCH.set_comment_symbol(";")
+```
+*huff* that took me 30 minutes to write... (all of the time was because of the comments XD)\
+Anyway... let's go over what the eclipse is all of these before my head explodes
+
+`ARCH.reset()`
+
+Resets the ARCH's PC and Program
+
+`ARCH.add_register("Register name")`
+
+adds a register
+
+`ARCH.add_ram(400,200)`
+
+set's the ram size which with this one will be... *give me a sec i'm calculating...* 80000 cells... *WOW*
+
+`ARCH.set_max(0xffffffff)`
+
+sets the integer limit, I just put the 32 bit limit because it's the bare minimum *trust me with this, you are going to need **much** more than 4294967295 bits **trust me***
+
+`ARCH.set_comment_symbol(";")`
+
+This Sets the comment symbol, any line that starts with it will be ignored in the assembler.\
+
+Now that we got that covered it's time to add some opcodes so we can actually do stuff
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+# no reset does NOT reset the ARCH's registers and ram it just resets the ARCH's PC and Program
+ARCH.reset()
+# The name of the Register doesn't matter go crazy if you want
+# The amount of Registers also don't matter, you can add like 50 of them and it wouldn't care
+ARCH.add_register("Rxa")
+ARCH.add_register("Rxb")
+ARCH.add_register("Rxc")
+ARCH.add_register("Rxe")
+# the size is calculated by the x (400) times the y (200)
+ARCH.add_ram(400,200)
+# 32 bit integer limit
+ARCH.set_max(0xffffffff)
+# we're setting the command symbol to be ; so it's like real ASM
+ARCH.set_comment_symbol(";")
+def MOV(reg,value):
+    ARCH.set_register(reg,value)
+def LOG(txt):
+    if txt in ARCH.registers:
+        print(ARCH.registers[txt])
+    else:
+        print(txt)
+# It's important to note that when adding opcodes don't put parentheses on the function
+# ARCH.add_opcode(0x0,MOV()) <-- incorrect, paratheses arnt opposed to be in the opcodes 
+# ARCH.add_opcode(0x0,MOV) <-- correct
+ARCH.add_opcode(0x0,MOV)
+ARCH.add_opcode(0x1,LOG)
+c="""
+MOV Rxa 10
+LOG Rxa
+"""
+ARCH.assemble(c)
+ARCH.run()
+```
+Okay there's a lot of stuff here so let's talk about the things that changed
+
+`ARCH.add_opcode(hex_ID function)`
+
+This adds an opcode, and when adding the function, please, **do not add parentheses**
+
+`ARCH.assemble(code)`
+
+This assembles the code from ASM format into something that the CPU can actually understand, then it loads it into the CPU's program ready to run.
+
+`ARCH.run()`
+
+This takes the code from the Program and runs it, simple and very useful.
+
+Now let's talk about the ASM format
+```AngelASM
+MOV Rxa 10
+LOG Rxa
+```
+The command comes first, each argument comes after the command separated by spaces, but then you might be wondering, "what about strings with spaces in them?" well, strings are strings so there has to be these (") surrounding them, without that it wouldn't be a string!
+
+Alright this is taking a long time and **I'm** running out of time so I'll just give you a dump of the commands, you should be able to tell what they do...
+```ASM_helper
+add_regiser
+add_ram
+add_opcode
+add_intruction
+
+set_window_name
+set_max
+set_pc
+set_register
+set_ram
+reset
+set_comment_symbol
+
+get_register
+get_ram
+get_pc
+
+text
+wait
+scroll
+is_Mouse_Touching_Surface
+show_mouse
+quit
+frame
+load_pixels
+events
+clear
+clear_logs
+is_held
+render_surfaces
+add_surface
+add_pixel
+text_input
+mouse_down_on_group
+mouse_pos
+
+assemble
+
+run
+```
+*huff* alright, that's all of them....\
+that's it for now, bye!

angel_cpu-0.1/angel_cpu/Angel.py

@@ -0,0 +1,388 @@
+import pygame
+import sys
+from ctypes import *
+import shlex
+import ast
+import os
+__Version__="0.1"
+if sys.platform == "win32":
+    from ctypes import windll
+    try:
+        windll.shcore.SetProcessDpiAwareness(1)
+    except:
+        pass
+class screen:
+    def __init__(self,font="consolas",fontsize=24):
+        pygame.init()
+        pygame.display.set_caption("<Undefined ARCH>")
+        self.clock=pygame.time.Clock()
+        self.clock.tick(60)
+        self.screen = pygame.display.set_mode((600, 600))
+        self.font = pygame.font.SysFont(font, fontsize)
+        self.pixel_layer=pygame.Surface(self.screen.get_size(), pygame.SRCALPHA)
+        self.printBuffer=[]
+        self.y=0
+        self.held_keys = {}
+        self.txtlog=[]
+        self.colorlog=[]
+        self.endlog=[]
+        self.xlog=[]
+        self.pixellog=[]
+        self.surfaces={}
+        self.ylog=[]
+    def text(self,txt,x,color=(255,255,255),AddToTxtLog=True,end="\n",customy=(False,0)):
+        lines=txt.split("\n")
+        for line in lines:
+            if customy[0]==True:
+                self.screen.blit(self.font.render(line, True, color),(x,customy[1]))
+            else:
+                self.screen.blit(self.font.render(line, True, color), (x, self.y))
+            if end=="\n" and customy[0]==False:
+                self.y+=20
+            if AddToTxtLog:
+                self.txtlog.append(line)
+                self.colorlog.append(color)
+                self.endlog.append(end)
+                self.xlog.append(x)
+                if customy[0]==True:
+                    self.ylog.append(customy)
+                else:
+                    self.ylog.append((False,self.y))
+    def clear(self):
+        self.screen.fill((0, 0, 0))
+        self.pixel_layer.fill((0,0,0,0))
+        self.y=0
+    def events(self):
+        ES = "n"
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()
+            elif event.type == pygame.KEYDOWN:
+                key_name = pygame.key.name(event.key)
+                ES = f"kDWN{key_name}"
+                self.held_keys[key_name] = True
+            elif event.type == pygame.KEYUP:
+                key_name = pygame.key.name(event.key)
+                ES = f"kUP{key_name}"
+                self.held_keys[key_name] = False
+            elif event.type == pygame.MOUSEBUTTONDOWN:
+                ES = ("mDWN",pygame.mouse.get_pos())
+            elif event.type == pygame.MOUSEBUTTONUP:
+                ES = ("mUP",pygame.mouse.get_pos())
+        return ES
+    def isHeld(self, kName):
+        return self.held_keys.get(kName, False)
+    def input(self, prompt="", promptcolor=(255, 255, 255), promtend="", promptx = 0):
+        itext = ""
+        basey=self.y
+        blink=""
+        blinktime=0
+        while True:
+            self.clear()
+            self.loadpixels()
+            i=0
+            for line in self.txtlog:
+                display = "".join(line)
+                color=self.colorlog[i]
+                end=self.endlog[i]
+                x=self.xlog[i]
+                y=self.ylog[i]
+                i+=1
+                self.text(display, x,color,False,end=end,customy=(y))
+            i2=0
+            for j in self.pixellog:
+                px = self.pixellog[i2][0][0]
+                py = self.pixellog[i2][0][1]
+                pcol = self.pixellog[i2][1]
+                psize = self.pixellog[i2][2]
+                pgroup = self.pixellog[i2][3]
+                self.pixel(px, py, pcol, psize, pgroup, False)
+                i2+=1
+            self.text(prompt + itext+blink, promptx, promptcolor, False, end=promtend,)  # display current input
+            self.loadpixels()
+            pygame.display.flip()
+            event=pygame.event.wait()
+            if event.type == pygame.QUIT:
+                sys.exit()  # user closed the window
+            elif event.type == pygame.KEYDOWN:
+                key_name = pygame.key.name(event.key)
+                if key_name == "backspace":
+                    itext = itext[:-1]
+                elif key_name == "return":
+                    return itext
+                elif key_name == "space":
+                    itext += " "
+                elif len(key_name) == 1:
+                    itext += self.keyNameWithShift(event)
+    def clearlogs(self):
+            self.txtlog=[]
+            self.colorlog=[]
+            self.endlog=[]
+            self.xlog=[]
+            self.pixellog=[]
+            self.surfaces={}
+            self.ylog=[]
+    def keyNameWithShift(self, event):
+        key_name = pygame.key.name(event.key)
+        shift_held = pygame.key.get_mods() & pygame.KMOD_SHIFT
+        if key_name.isalpha() and shift_held:
+            key_name = key_name.upper()
+        shift_map = {
+            '1': '!', '2': '@', '3': '#', '4': '$', '5': '%',
+            '6': '^', '7': '&', '8': '*', '9': '(', '0': ')',
+            '-': '_', '=': '+', '[': '{', ']': '}', '\\': '|',
+            ';': ':', "'": '"', ',': '<', '.': '>', '/': '?',
+            '`': '~'
+        }
+        if key_name in shift_map and shift_held:
+            key_name = shift_map[key_name]
+        return key_name
+    def newframe(self):
+        self.rendersurfaces()
+        self.screen.blit(self.pixel_layer, (0, 0))
+        pygame.display.flip()
+        self.clock.tick(60)
+    def pixel(self, x=0, y=0, color=(255, 255, 255),size=1,group=None,addtopixellog=True):
+        pygame.draw.rect(self.pixel_layer, color, (x, y, size, size))
+        if addtopixellog==True:
+            self.pixellog.append(((x,y), color, size,group))
+        else:
+            pass
+    def loadpixels(self):
+        self.screen.blit(self.pixel_layer, (0, 0))
+    def MouseClickedOnGroup(self, event, group=None):
+        if isinstance(event, tuple) and event[0] == "mDWN":
+            mouse_x, mouse_y = event[1]
+            for px, color, size, pxgroup in self.pixellog:
+                if pxgroup == group:
+                    px_x, px_y = px
+                    if px_x <= mouse_x < px_x + size and px_y <= mouse_y < px_y + size:
+                        return True
+        return False
+    def MousePos(self):
+        return pygame.mouse.get_pos()
+    def showmouse(self,visibility=True):
+        pygame.mouse.set_visible(visibility)
+    def quit(self):
+        pygame.quit()
+        sys.exit()
+    def addsurface(self,name,width,height,col=(0,0,255),posx=0,posy=0):
+        self.surfaces[name]={}
+        self.surfaces[name]["data"]=pygame.Surface((width,height),pygame.SRCALPHA)
+        self.surfaces[name]["data"].fill(col)
+        self.surfaces[name]["pos"]=(posx,posy)
+        self.surfaces[name]["rect"]= self.surfaces[name]["data"].get_rect(topleft=(posx, posy))
+    def rendersurfaces(self):
+        for name in self.surfaces:
+            self.screen.blit(self.surfaces[name]["data"], self.surfaces[name]["pos"])
+    def mouseTouchingSurface(self, name):
+        mouse_pos = pygame.mouse.get_pos()
+        return self.surfaces[name]["rect"].collidepoint(mouse_pos)
+    def wait(self,t):
+        pygame.time.wait(t)
+    def scroll(self,dx,dy):
+        self.screen.scroll(dx,dy)
+    def SetWindowName(self,name):
+        pygame.display.set_caption(f"{name}")
+class cpu:
+    def __init__(self,Arch_name="Undefined ARCH"):
+        self.registers={}
+        self.ram={}
+        self.opcodes={}
+        self.pc=0
+        self.MaxValue=0xffffffff
+        self.program=[]
+        self.sc=screen()
+        self.comment_symbol=";"
+        self.Arch_name=Arch_name
+        self.sc.SetWindowName(Arch_name)
+        self.BuildCommands={}
+    #-/main/-#
+    def main(self):
+        self.set_window_name("<ANGEL>")
+        self.text("welcome to Angel-CPU",0)
+        self.frame()
+        self.text("Type CMD for a list of commands",0)
+        self.frame()
+        while True:
+            i=self.text_input(">",(255,0,0))
+            if i == "CMD":
+                self.clear()
+                self.clear_logs()
+                self.text("CMD: lists commands",0)
+                self.text("INFO: Displays Information about Angel",0)
+                self.text("Version: Displays Angel's Version",0)
+                self.frame()
+                self.text_input("press enter to continue...")
+            elif i == "INFO":
+                self.clear()
+                self.clear_logs()
+                self.text("<Angel>: A CPU framework for",0)
+                self.text("building virtual CPUs in python,",0)
+                self.text("You can find more information about",0)
+                self.text("Angel in the README file.",0)
+                self.frame()
+                self.text_input("press enter to continue...")
+            elif i == "Version":
+                self.text(f"Angel Version:{__Version__}",0)
+                self.text_input("press enter to continue...")
+                self.clear_logs()
+                self.clear()
+    #-/add's/-#
+    def add_register(self,register):
+        self.registers[register]=0x0
+    def add_ram(self,size_x,size_y):
+        self.ram=[0x0]*size_x*size_y
+    def add_opcode(self,opcode,command):
+        self.opcodes[opcode]=command
+    def add_instruction(self,instruction):
+        self.program.append(instruction)
+    #-/set's/-#
+    def set_window_name(self,name):
+        self.sc.SetWindowName(name)
+    def set_max(self,max):
+        self.MaxValue=max
+    def set_pc(self,pc):
+        self.pc=pc
+    def set_register(self,register,value):
+        if type(value) == int:
+            if value <= self.MaxValue:
+                self.registers[register]=value
+            else:
+                self.registers[register]=0x0
+        elif type(value) == str:
+            if len(value) <= self.MaxValue:
+                self.registers[register]=value
+            else:
+                self.registers[register]=""
+        elif type(value) == tuple:
+            if len(value) <= self.MaxValue:
+                self.registers[register]=value
+            else:
+                self.registers[register]=()
+        elif type(value) == list:
+            if len(value) <= self.MaxValue:
+                self.registers[register]=value
+            else:
+                self.registers[register]=[]
+        elif type(value) == dict:
+            if len(value) <= self.MaxValue:
+                self.registers[register]=value
+            else:
+                self.registers[register]={}
+    def set_ram(self,addr,value):
+        if type(addr) == int:
+            if addr <= self.MaxValue:
+                self.ram[addr]=value
+            else:
+                self.ram[addr]=0x0
+        if type(addr) == str:
+            if len(addr) <= self.MaxValue:
+                self.ram[addr]=value
+            else:
+                self.ram[addr]=""
+        if type(addr) == tuple:
+            if len(addr) <= self.MaxValue:
+                self.ram[addr]=value
+            else:
+                self.ram[addr]=()
+        if type(addr) == list:
+            if len(addr) <= self.MaxValue:
+                self.ram[addr]=value
+            else:
+                self.ram[addr]=[]
+        if type(addr) == dict:
+            if len(addr) <= self.MaxValue:
+                self.ram[addr]=value
+            else:
+                self.ram[addr]={}
+    def reset(self):
+        self.pc=0
+        self.program=[]
+    def set_comment_symbol(self,symbol):
+        self.comment_symbol=symbol
+    #-/Get's/-#
+    def get_register(self,register):
+        return self.registers[register]
+    def get_ram(self,addr):
+        return self.ram[addr]
+    def get_pc(self):
+        return self.pc
+    #-/screen/-#
+    def text(self, txt, x, color=(255, 255, 255), AddToTxtLog=True, end="\n", customy=(False, 0)):
+        self.sc.text(txt, x, color, AddToTxtLog, end, customy)
+    def wait(self,t):
+        self.sc.wait(t)
+    def scroll(self,dx,dy):
+        self.sc.scroll(dx,dy)
+    def is_Mouse_Touching_Surface(self,name):
+        return self.sc.mouseTouchingSurface(name)
+    def show_mouse(self,visibility=True):
+        self.sc.showmouse(visibility)
+    def quit(self):
+        pygame.quit()
+        sys.exit()
+    def frame(self):
+        self.sc.newframe()
+    def load_pixels(self):
+        self.sc.loadpixels()
+    def events(self):
+        self.sc.events()
+    def clear(self):
+        self.sc.clear()
+    def clear_logs(self):
+        self.sc.clearlogs()
+    def is_held(self,key):
+        return self.sc.isHeld(key)
+    def render_surfaces(self):
+        self.sc.rendersurfaces()
+    def add_surface(self,name,width,height,col=(0,0,255),posx=0,posy=0):
+        self.sc.addsurface(name,width,height,col,posx,posy)
+    def add_pixel(self, x=0, y=0, color=(255, 255, 255),size=1,group=None,addtopixellog=True):
+        self.sc.pixel(x,y,color,size,group,addtopixellog)
+    def text_input(self, prompt="", promptcolor=(255, 255, 255), promtend="", promptx = 0):
+        return self.sc.input(prompt,promptcolor,promtend,promptx)
+    def mouse_down_on_group(self,event,group=None):
+        return self.sc.MouseClickedOnGroup(event,group)
+    def mouse_pos(self):
+        return self.sc.MousePos()
+    #-/assembler/-#
+    def assemble(self, code):
+        lines = code.strip().split("\n")
+        name_to_opcode = {}
+        for opcode, func in self.opcodes.items():
+            name_to_opcode[func.__name__.upper()] = opcode
+        for line in lines:
+            line = line.strip()
+            if line.startswith(self.comment_symbol):
+                continue
+            if not line:
+                continue
+            parts = shlex.split(line)
+            inst_name = parts[0].upper()
+            args = []
+            for arg in parts[1:]:
+                try:
+                    value = ast.literal_eval(arg)
+                except:
+                    value = arg
+                args.append(value)
+            if inst_name in name_to_opcode:
+                self.add_instruction((name_to_opcode[inst_name], tuple(args)))
+            else:
+                raise Exception(f"Unknown instruction: {inst_name}")
+    #-/run/-#
+    def run(self):
+        while self.pc<len(self.program):
+            command=self.program[self.pc][0]
+            args=self.program[self.pc][1]
+            self.pc+=1
+            for opcode in self.opcodes:
+                if opcode==command:
+                    self.opcodes[opcode](*args)
+def main():
+    Angel = cpu("<Angel>")
+    Angel.main()
+if __name__ == "__main__":
+    main()

angel_cpu-0.1/angel_cpu/__init__.py

@@ -0,0 +1 @@
+from Angel import *

angel_cpu-0.1/angel_cpu.egg-info/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: angel-cpu
+Version: 0.1
+Summary: A CPU framework
+Home-page: 
+Author: ERROR-Xmakernotfound
+Author-email: 
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Hello!\
+Have you ever tried to make a cpu simulation but don't want to write 300+ lines of code?\
+Well then you don't have to anymore!\
+AngelCPU does most of the heavy lifting for you, so let's get started before I fall asleep while typing this.
+# Getting Started
+First lets install Angel
+```bash
+pip install angel-cpu
+```
+Now, let's start with some simple stuff,
+*give me a second i'm setting up*
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+```
+*Alright now i'm done setting up.*
+As you can see we have a class here
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")#THIS RIGHT HERE
+```
+Let's first set up the basic CPU ARCH
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+# no reset does NOT reset the ARCH's registers and ram it just resets the ARCH's PC and Program
+ARCH.reset()
+# The name of the Register doesn't matter go crazy if you want
+# The amount of Registers also don't matter, you can add like 50 of them and it wouldn't care
+ARCH.add_register("Rxa")
+ARCH.add_register("Rxb")
+ARCH.add_register("Rxc")
+ARCH.add_register("Rxe")
+# the size is calculated by the x (400) times the y (200)
+ARCH.add_ram(400,200)
+# 32 bit integer limit
+ARCH.set_max(0xffffffff)
+# we're setting the command symbol to be ; so it's like real ASM
+ARCH.set_comment_symbol(";")
+```
+*huff* that took me 30 minutes to write... (all of the time was because of the comments XD)\
+Anyway... let's go over what the eclipse is all of these before my head explodes
+
+`ARCH.reset()`
+
+Resets the ARCH's PC and Program
+
+`ARCH.add_register("Register name")`
+
+adds a register
+
+`ARCH.add_ram(400,200)`
+
+set's the ram size which with this one will be... *give me a sec i'm calculating...* 80000 cells... *WOW*
+
+`ARCH.set_max(0xffffffff)`
+
+sets the integer limit, I just put the 32 bit limit because it's the bare minimum *trust me with this, you are going to need **much** more than 4294967295 bits **trust me***
+
+`ARCH.set_comment_symbol(";")`
+
+This Sets the comment symbol, any line that starts with it will be ignored in the assembler.\
+
+Now that we got that covered it's time to add some opcodes so we can actually do stuff
+```python
+from angel_cpu import *
+ARCH=cpu("ARCH")
+# no reset does NOT reset the ARCH's registers and ram it just resets the ARCH's PC and Program
+ARCH.reset()
+# The name of the Register doesn't matter go crazy if you want
+# The amount of Registers also don't matter, you can add like 50 of them and it wouldn't care
+ARCH.add_register("Rxa")
+ARCH.add_register("Rxb")
+ARCH.add_register("Rxc")
+ARCH.add_register("Rxe")
+# the size is calculated by the x (400) times the y (200)
+ARCH.add_ram(400,200)
+# 32 bit integer limit
+ARCH.set_max(0xffffffff)
+# we're setting the command symbol to be ; so it's like real ASM
+ARCH.set_comment_symbol(";")
+def MOV(reg,value):
+    ARCH.set_register(reg,value)
+def LOG(txt):
+    if txt in ARCH.registers:
+        print(ARCH.registers[txt])
+    else:
+        print(txt)
+# It's important to note that when adding opcodes don't put parentheses on the function
+# ARCH.add_opcode(0x0,MOV()) <-- incorrect, paratheses arnt opposed to be in the opcodes 
+# ARCH.add_opcode(0x0,MOV) <-- correct
+ARCH.add_opcode(0x0,MOV)
+ARCH.add_opcode(0x1,LOG)
+c="""
+MOV Rxa 10
+LOG Rxa
+"""
+ARCH.assemble(c)
+ARCH.run()
+```
+Okay there's a lot of stuff here so let's talk about the things that changed
+
+`ARCH.add_opcode(hex_ID function)`
+
+This adds an opcode, and when adding the function, please, **do not add parentheses**
+
+`ARCH.assemble(code)`
+
+This assembles the code from ASM format into something that the CPU can actually understand, then it loads it into the CPU's program ready to run.
+
+`ARCH.run()`
+
+This takes the code from the Program and runs it, simple and very useful.
+
+Now let's talk about the ASM format
+```AngelASM
+MOV Rxa 10
+LOG Rxa
+```
+The command comes first, each argument comes after the command separated by spaces, but then you might be wondering, "what about strings with spaces in them?" well, strings are strings so there has to be these (") surrounding them, without that it wouldn't be a string!
+
+Alright this is taking a long time and **I'm** running out of time so I'll just give you a dump of the commands, you should be able to tell what they do...
+```ASM_helper
+add_regiser
+add_ram
+add_opcode
+add_intruction
+
+set_window_name
+set_max
+set_pc
+set_register
+set_ram
+reset
+set_comment_symbol
+
+get_register
+get_ram
+get_pc
+
+text
+wait
+scroll
+is_Mouse_Touching_Surface
+show_mouse
+quit
+frame
+load_pixels
+events
+clear
+clear_logs
+is_held
+render_surfaces
+add_surface
+add_pixel
+text_input
+mouse_down_on_group
+mouse_pos
+
+assemble
+
+run
+```
+*huff* alright, that's all of them....\
+that's it for now, bye!

angel_cpu-0.1/angel_cpu.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+angel_cpu/Angel.py
+angel_cpu/__init__.py
+angel_cpu.egg-info/PKG-INFO
+angel_cpu.egg-info/SOURCES.txt
+angel_cpu.egg-info/dependency_links.txt
+angel_cpu.egg-info/entry_points.txt
+angel_cpu.egg-info/requires.txt
+angel_cpu.egg-info/top_level.txt

angel_cpu-0.1/angel_cpu.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

angel_cpu-0.1/angel_cpu.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+Angel = Angel:main

angel_cpu-0.1/angel_cpu.egg-info/requires.txt

@@ -0,0 +1 @@
+pygame

angel_cpu-0.1/angel_cpu.egg-info/top_level.txt

@@ -0,0 +1 @@
+angel_cpu

angel_cpu-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

angel_cpu-0.1/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+setup(
+    name="angel-cpu",
+    version="0.1",
+    author="ERROR-Xmakernotfound",
+    author_email="",
+    description="A CPU framework",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    url="",
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=[
+        "pygame",
+    ],
+    entry_points={
+        "console_scripts": [
+            "Angel=Angel:main",
+        ],
+    },
+)