[GL] fix(runtime): small fixes

GameLogic/Engine/Geometry.py

@@ -2,11 +2,10 @@
 
 from Engine_Geometry import *
 
+from math import atan2, cos, sin
 from typing import List
 
-
-class Vector2D(object):
-	"""Vector2D Class"""
+class Vector2D:
 	def __init__(self, x, y):
 		self.x = x
 		self.y = y
@@ -34,8 +33,8 @@ def Angle(self) -> float:
 
 	def Rotate(self, angleToRotate: float) -> Vector2D:
 		"""Rotates this vector by an input angle in radians"""
-		mag = self.return_magnitude()
-		ang = self.return_angle()
+		mag = self.Magnitude()
+		ang = self.Angle()
 		x = mag * cos(ang + angleToRotate)
 		y = mag * sin(ang + angleToRotate)
 		return Vector2D(x, y)
@@ -90,8 +89,7 @@ def _FromEngineVec(cls, engineVec):
 		return cls(engineVec.x, engineVec.y)
 
 
-class Vector(object):
-	"""Vector Class"""
+class Vector:
 	def __init__(self, x=0, y=0, z=0):
 		self.x = x
 		self.y = y
@@ -178,7 +176,7 @@ class Direction(eDirection):
 
 
 def DirectionToVect(dir: Direction) -> Vector2D:
-	return Vector2D.__FromEngineVect(eDirectionToVect(dir))
+	return Vector2D._FromEngineVect(eDirectionToVect(dir))
 
 
 def InvertDirection(dir: Direction) -> Direction:
@@ -195,11 +193,11 @@ def Add(self, directions: List[Direction]):
 	def Remove(self, directions: List[Direction]):
 		self._impl.Remove(directions)
 
-	def IsExistOne(self, directions: List[Direction]) -> bool:
-		return self._impl.IsExistOne(directions)
+	def DoesExistOne(self, directions: List[Direction]) -> bool:
+		return self._impl.DoesExistOne(directions)
 
-	def AreExistAll(self, directions: List[Direction]) -> bool:
-		return self._impl.IsExistOne(directions)
+	def DoExistAll(self, directions: List[Direction]) -> bool:
+		return self._impl.DoExistAll(directions)
 
 	def Reset(self):
 		self._impl.Reset()

GameLogic/Engine/World.py

@@ -54,13 +54,13 @@ def map(self) -> Map:
 		return Map(self._impl.map)
 
 	def IsDense(self, directions: DirectionSet) -> bool:
-		return self._impl.IsDense(directions)
+		return self._impl.IsDense(directions._impl)
 
 	def IsSpace(self) -> bool:
 		return self._impl.IsSpace()
 
 	def GetDenseObject(self, directions: DirectionSet) -> Object:
-		return self._impl.GetDenseObject(directions)
+		return self._impl.GetDenseObject(directions._impl)
 
 
 class Object(eObject):
@@ -201,7 +201,7 @@ def _pushToIcons(self, icon):
 		super()._pushToIcons(icon)
 
 
-def CreateObject(type: str, tile: Tile) -> Object:
+def CreateObject(type: str, tile: Tile = None) -> Object:
 	if isinstance(tile, Tile):
 		# called from scripts
 		return eCreateObject(type, tile._impl)
@@ -282,10 +282,10 @@ def id(self, value: str):
 		super(ControlUIElement, self.__class__).id.fset(self, value)
 
 	@property
-	def position(self) -> Vector:
+	def position(self) -> Vector2D:
 		return Vector2D._FromEngineVec(super().position)
 	@position.setter
-	def position(self, value: Vector):
+	def position(self, value: Vector2D):
 		super(ControlUIElement, self.__class__).position.fset(self, eVec2i(value.x, value.y))
 
 	def RegisterCallback(self, action: Callable[[], None]):

GameLogic/Objects/Creature.py

@@ -19,7 +19,7 @@ def __init__(self):
 
 		self.AddComponent("Control")
 		self.control = self.GetComponent("Control")
-		self.DefineUI(self.control.ui)
+		self._defineUI(self.control.ui)
 
 	@property
 	def seeInvisibleAbility(self):
@@ -33,7 +33,7 @@ def seeInvisibleAbility(self, value):
 			self.__seeInvisibleAbility = value
 			self.control.seeInvisibleAbility = value
 
-	def DefineUI(self, ui):
+	def _defineUI(self, ui):
 		pass
 
 	def Update(self, timeElapsed):

GameLogic/Objects/Creatures/Human.py

@@ -22,72 +22,72 @@ def CreateOrgans(self):
 		self.organs.rightHand = self.AddOrgan(Hand())
 
 	# Creature methods
-	def DefineUI(self, ui):
-		self.__uiFields = types.SimpleNamespace()
+	def _defineUI(self, ui):
+		self._uiFields = types.SimpleNamespace()
 
 		element = ControlUIElement()
 		element.id = "lhand"
 		element.position = Vector2D(ui.center.x, ui.resolution.y - ui.iconSize.y)
 		element.AddIcon("lhand_inactive")
 		element.RegisterCallback(lambda element=element: self.__uiFieldClicked(element))
 		ui.UpdateElement(element)
-		self.__uiFields.lhand = element
+		self._uiFields.lhand = element
 
 		element = ControlUIElement()
 		element.id = "rhand"
 		element.position = Vector2D(ui.center.x - ui.iconSize.x, ui.resolution.y - ui.iconSize.y)
 		element.AddIcon("rhand_inactive")
 		element.RegisterCallback(lambda element=element: self.__uiFieldClicked(element))
 		ui.UpdateElement(element)
-		self.__uiFields.rhand = element
+		self._uiFields.rhand = element
 
 		element = ControlUIElement()
 		element.id = "equip"
 		element.position = Vector2D(ui.center.x - ui.iconSize.x, ui.resolution.y - ui.iconSize.y * 2)
 		element.AddIcon("equip")
 		element.RegisterCallback(lambda element=element: self.__uiFieldClicked(element))
 		ui.UpdateElement(element)
-		self.__uiFields.equip = element
+		self._uiFields.equip = element
 
 		element = ControlUIElement()
 		element.id = "swap1"
 		element.position = Vector2D(ui.center.x - ui.iconSize.x, ui.resolution.y - ui.iconSize.y * 2)
 		element.AddIcon("swap1")
 		element.RegisterCallback(lambda element=element: self.__uiFieldClicked(element))
 		ui.UpdateElement(element)
-		self.__uiFields.swap1 = element
+		self._uiFields.swap1 = element
 
 		element = ControlUIElement()
 		element.id = "swap2"
 		element.position = Vector2D(ui.center.x, ui.resolution.y - ui.iconSize.y * 2)
 		element.AddIcon("swap2")
 		element.RegisterCallback(lambda element=element: self.__uiFieldClicked(element))
 		ui.UpdateElement(element)
-		self.__uiFields.swap2 = element
+		self._uiFields.swap2 = element
 
 		element = ControlUIElement()
 		element.id = "pocket1"
 		element.position = Vector2D(ui.center.x + ui.iconSize.x, ui.resolution.y - ui.iconSize.y)
 		element.AddIcon("pocket")
 		element.RegisterCallback(lambda element=element: self.__uiFieldClicked(element))
 		ui.UpdateElement(element)
-		self.__uiFields.pocket1 = element
+		self._uiFields.pocket1 = element
 
 		element = ControlUIElement()
 		element.id = "pocket2"
 		element.position = Vector2D(ui.center.x + ui.iconSize.x * 2, ui.resolution.y - ui.iconSize.y)
 		element.AddIcon("pocket")
 		element.RegisterCallback(lambda element=element: self.__uiFieldClicked(element))
 		ui.UpdateElement(element)
-		self.__uiFields.pocket2 = element
+		self._uiFields.pocket2 = element
 
 	def RemoveObject(self, object) -> bool:
 		for hand in self.hands:
 			if object is hand.holdedItem:
 				if hand is self.organs.leftHand:
-					self.__uiFields.lhand.PopIcon()
+					self._uiFields.lhand.PopIcon()
 				else:
-					self.__uiFields.rhand.PopIcon()
+					self._uiFields.rhand.PopIcon()
 
 		return super().RemoveObject(object)
 
@@ -96,9 +96,9 @@ def Take(self, object) -> bool:
 			return False
 
 		if self.activeHand is self.organs.leftHand:
-			self.__uiFields.lhand.AddIcon(object.sprite)
+			self._uiFields.lhand.AddIcon(object.sprite)
 		else:
-			self.__uiFields.rhand.AddIcon(object.sprite)
+			self._uiFields.rhand.AddIcon(object.sprite)
 
 		return True
 
@@ -115,25 +115,25 @@ def GetSlotItem(self, mobSlot) -> Item:
 
 	# Human methods
 	def __uiFieldClicked(self, field):
-		if field is self.__uiFields.lhand:
+		if field is self._uiFields.lhand:
 			self.activeHand = self.organs.leftHand
 			self.__updateActiveHandIcon()
-		elif field is self.__uiFields.rhand:
+		elif field is self._uiFields.rhand:
 			self.activeHand = self.organs.rightHand
 			self.__updateActiveHandIcon()
 
 	def __updateActiveHandIcon(self):
-		self.__uiFields.lhand.ClearIcons()
-		self.__uiFields.rhand.ClearIcons()
+		self._uiFields.lhand.ClearIcons()
+		self._uiFields.rhand.ClearIcons()
 
 		if self.activeHand is self.organs.leftHand:
-			self.__uiFields.lhand.AddIcon("lhand_active")
-			self.__uiFields.rhand.AddIcon("rhand_inactive")
+			self._uiFields.lhand.AddIcon("lhand_active")
+			self._uiFields.rhand.AddIcon("rhand_inactive")
 		else:
-			self.__uiFields.lhand.AddIcon("lhand_inactive")
-			self.__uiFields.rhand.AddIcon("rhand_active")
+			self._uiFields.lhand.AddIcon("lhand_inactive")
+			self._uiFields.rhand.AddIcon("rhand_active")
 
 		if self.organs.leftHand.holdedItem:
-			self.__uiFields.lhand.AddIcon(self.organs.leftHand.holdedItem.sprite)
+			self._uiFields.lhand.AddIcon(self.organs.leftHand.holdedItem.sprite)
 		if self.organs.rightHand.holdedItem:
-			self.__uiFields.rhand.AddIcon(self.organs.rightHand.holdedItem.sprite)
+			self._uiFields.rhand.AddIcon(self.organs.rightHand.holdedItem.sprite)