Emil_Shanaty/TheMatrixUniverse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make basis for engine

Browse Source
This commit is contained in:
emil
2024-10-22 14:46:05 +03:00
parent 8b0281ac26
commit 539968cf08
1 changed files with 13 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main.py
+13 -259
View File
@@ -27,10 +27,12 @@ class Cell:
def clear_perceptor(self):
self.perceptor = None
def draw(self):
pg.draw.rect(screen, "white", self.rect)
if self.perceptor == None:
pg.draw.rect(screen, "white", self.rect)
else:
pg.draw.rect(screen, self.perceptor.color, self.rect) #TODO:DELETE THIS AND MAKE OVERLAPING HALF_TRANSPARENT ADDITIONAL CELLS SPAWNIN UNDER PERCEPTION IN NEO CLASS
pg.draw.rect(screen, self.perceptor.color, self.rect)
g_font = pg.font.Font(None, 14)
text = g_font.render((str)(self.g), True, "black")
@@ -40,7 +42,6 @@ class Cell:
text = h_font.render((str)(self.h), True, "black")
screen.blit(text, ((self.coordinates[0] + self.size * 0.8, self.coordinates[1] + self.size * 0.75)))
f_font = pg.font.Font(None, 16)
text = f_font.render((str)(self.f), True, "maroon")
screen.blit(text, ((self.coordinates[0] + self.size * 0.425, self.coordinates[1] + self.size * 0.7)))
@@ -125,16 +126,17 @@ class Neo(Actor):
self.position[0] + self.perception_radius + 1):
for y in range(self.position[1] - self.perception_radius,
self.position[1] + self.perception_radius + 1):
if (x != self.position[0] or y != self.position[1]):
self.percepted_cells.append(map.get_cell(x, y)) #set current percieved cells
if 0 <= x < map.dimensions[0] and 0 <= y < map.dimensions[1]:
if (x != self.position[0] or y != self.position[1]):
self.percepted_cells.append(map.get_cell(x, y)) #set current percieved cells
#set perceptors
for i in self.percepted_cells:
if (i != None):
i.set_perceptor(self)
map.draw()
pg.display.update()
pass
class Smith(Actor):
def __init__(self, cell_position):
@@ -212,7 +214,6 @@ def move(x, y):
print(f"m {x} {y}")
map = Map((8, 8))
neo = Neo((3, 3))
neo.perception_radius = 2
@@ -220,12 +221,13 @@ smith = Smith((1,1))
sentinel = Sentinel((3,4))
keymaker = Keymaker((5,5))
pg.init()
screen = pg.display.set_mode([512,512])
screen = pg.display.set_mode([1124,1124])
pg.display.set_caption("Matrix Universe")
running = True
#pg.time.delay(7000)
move(0, 0)
read_initial_inputs()
pg.time.delay(1500)
while running:
for event in pg.event.get():
if event.type == pg.QUIT:
@@ -240,23 +242,11 @@ while running:
pg.display.update()
move_input = read_input()
pg.time.delay(1500)
move((int)(move_input[0]), (int)(move_input[1]))
'''
inpt = read_input()
item_position = ()
item_type = ""
if len(inpt) == 3:
item_position[0] = inpt[0]
item_position[1] = inpt[1]
item_type = inpt[2]
elif len(inpt) == 1:
pass
move(3,4)
'''
pg.display.update()
'''
@@ -277,239 +267,3 @@ while running:
#pg.time.delay(1000)
'''
import pygame as pg
CELLSIZE = 50
#TOOLS
class Vector2:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vector2(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector2(self.x - other.x, self.y - other.y)
def __mul__(self, other):
return Vector2(self.x * other, self.y * other)
def __truediv__(self, other):
return Vector2(self.x / other, self.y / other)
def __floordiv__(self, other):
return Vector2(self.x // other, self.y // other)
def magnitude(self):
return (self.x**2 + self.y**2)**0.5
def to_array(vector):
return [vector.x, vector.y]
def normalize(self):
length = self.magnitude()
return Vector2(self.x / length, self.y / length)
def set_from_tuple(self,tup):
self.x = tup[0]
self.y = tup[1]
#ENTITIES
class Entity:
coordinates = Vector2(0,0) ##PIXELS
position = Vector2(0,0) ##CELLS
name = ""
cell = None
def __init__(self, initial_position:tuple, name):
self.position.set_from_tuple(initial_position)
self.name = name
self.set_cell(initial_position[0], initial_position[1])
def set_cell(self, x, y):
map.get_cell(self.position.x,self.position.y).set_content(None)
self.position.set_from_tuple((x,y))
self.coordinates = map.cell_grid[x][y].coordinates
map.get_cell(x,y).set_content(self)
cell = map.get_cell(self.position.x,self.position.y)
def get_cell(self):
return self.cell
def draw(self, color):
font = pg.font.Font(None, 32)
text = font.render(self.name, True, color)
screen.blit(text, (self.coordinates + Vector2(0, 0)).to_array())
class Actor(Entity):
perception_radius = 0
perceived_cells = None
def __init__(self, initial_position, name, perception_radius):
super().__init__(initial_position, name)
self.perception_radius = perception_radius
class Neo(Actor):
key_maker_position = Vector2(0,0)
def __init__(self, initial_position, perception_radius, key_maker_position):
super().__init__(initial_position, "neo", 1)
self.key_maker_position = key_maker_position
def percept(self):
upper_left_corner_cell = map.get_cell(self.position.x - self.perception_radius, self.position.y - self.perception_radius)
for y in range(upper_left_corner_cell.position.y, upper_left_corner_cell.position.y + self.perception_radius * 2 + 1):
for x in range(upper_left_corner_cell.position.x, upper_left_corner_cell.position.x + self.perception_radius * 2 + 1):
#print(x,y)
if x < map.dimension.x and y < map.dimension.y:
cell = map.get_cell(x, y) #TODO:PROPER COLORIZE
print(x,y)
cell.add_perceptor(self)
#print(map.get_cell(x,y).perceptors[0].name)
#print(cell.position.to_array())
#print(cell.perceptors[0].name)
for x in range(8):
for y in range(8):
print(x,y)
print(map.get_cell(x,y).perceptors[0])
class Smith(Actor):
def __init__(self, initial_position, perception_radius):
super().__init__(initial_position, "smith", perception_radius)
def kill():
print("Neo is killed.") #TODO: delete
class Sentinel(Actor):
def __init__(self, initial_position, perception_radius):
super().__init__(initial_position, "sentinel", perception_radius)
def kill():
print("Neo is killed.") #TODO: delete
class Key_maker(Entity):
def __init__(self, initial_position):
super().__init__(initial_position, "key_maker")
class Backdoor_key(Entity):
def __init__(self, initial_position):
super().__init__(initial_position, "backdoor_key")
#MAIN
class Cell:
coordinates = Vector2(0,0)
position = Vector2(0,0)
size = 50
piece = pg.Rect(0, 0, size, size)
content = None
perceptors = [None]
color = (255, 255, 255)
def __init__(self, coordinates):
self.coordinates = coordinates
self.piece = pg.Rect(self.coordinates.x, self.coordinates.y, self.size, self.size)
def draw(self):
if self.has_perceptor("neo"):
#cell.set_color((0,255,0)) #TODO:COLORIZE
print(self.position.to_array())
pg.draw.rect(screen, "green", self.piece)
else:
#print(5555555555555555)
pg.draw.rect(screen, "white", self.piece)
def set_color(self, color):
self.color = color
def set_content(self, content):
self.content = content
def add_perceptor(self, new_perceptor):
self.perceptors.append(new_perceptor)
def delete_perceptor(self, redundant_perceptor):
if self.has_perceptor(redundant_perceptor.name):
self.perceptors.remove(redundant_perceptor)
else:
pass #print(123)
def has_perceptor(self, name):
for i in self.perceptors:
if (i != None and i.name == name):
#print(987654321)
#print(i)
#print(self.position.to_array())
return True
#print(123456)
return False
class Map:
cellSize = CELLSIZE
cell_grid = []
margin = 5
dimension = Vector2(8,8)
offset = Vector2(50, 50)
def __init__(self, dimension:tuple):
self.dimension.set_from_tuple(dimension)
for x in range(self.dimension.x):
col = []
for y in range(self.dimension.y):
cell = Cell(Vector2(self.offset.x + x * (self.cellSize + self.margin), self.offset.y + y * (self.cellSize + self.margin)))
cell.position = Vector2(x,y)
col.append(cell)
self.cell_grid.append(col)
def get_cell(self, x, y):
return self.cell_grid[x][y]
def draw(self):
for y in range(self.dimension.y):
for x in range(self.dimension.x):
self.cell_grid[x][y].draw()
pg.init()
screen = pg.display.set_mode([512,512])
pg.display.set_caption("Matrix Universe")
cell = Cell(coordinates=Vector2(50,50))
map = Map((8, 8))
neo = Neo((0,0), 1, (0,0))
neo.set_cell(4,5)
#smith = Smith((0,0),2)
#print(map.get_cell(4,5).content.name)
#print(map.get_cell(0,0).content)
running = True
while running:
for event in pg.event.get():
if event.type == pg.QUIT:
running = False
screen.fill('BLACK')
map.draw()
neo.draw("blue")
neo.percept()
neo.set_cell(1,1)
#print(map.get_cell(7,7).perceptors[0].name)
pg.display.update()
pg.time.delay(5000)
'''