### The Manager of object position in the World #import numpy as np import General import random from Coordinate import Coordinate from Automa import Automa from LoggerClass import Logger from Object import Object # LOGGING -- logger = Logger(module_name = __name__, class_name = 'Position_manager') class Position_manager: """ Manager of objects position Nota: usa un dictionary con key = Coordinate object quindi per utilizzare un elemento del dizionario mediante la Key devi utilizzare lo stesso oggetto non istanziare un altro oggetto con gli stessi valori """ # test: ok def __init__( self, name = 'Fuffy', limits = [ [-50, -50, -50], [50, 50, 50] ] ): self.name = name self.limits = limits self.pos = {} # index:(x,y,z), value:obj self.map = {} # index:(x, y, z), value: id_obj logger.logger.info("Position Manager created")
from LoggerClass import Logger import General # LOGGING -- logger = Logger(module_name=__name__, class_name='Coordinate') class Coordinate: """ Rappresents a coordinate in an x, y, z system """ def __init__(self, x=None, y=None, z=None): if x != None and not y and not z and General.checkPosition(x): self.x = x[0] self.y = x[1] self.z = x[2] elif x != None and isinstance(x, int) and y != None and isinstance( y, int) and z != None and isinstance(z, int): self.x = x self.y = y self.z = z elif not x and not y and not z: self.x = 0 self.y = 0 self.z = 0 else: raise Exception("Invalid properties! Coordinate not istantiate.")
from time import sleep import logging from LoggerClass import Logger Logger() logger = logging.getLogger(__name__) def expensive_func(): sleep(2) return 'expensive function' def function(): if logger.isEnabledFor(logging.INFO): logger.debug('%s', expensive_func()) logger.info('FUNCTION info')
import random from Coordinate import Coordinate import General from State import State from LoggerClass import Logger # LOGGING -- logger = Logger(module_name=__name__, class_name='Object') class Object: def __init__( self, dimension=(1, 1, 1), mass=0, resilience=100, emissivity={ "radio": 0, "thermal": 0, "optical": 0, "nuclear": 0, "electric": 0, "acoustics": 0, "chemist": 0 }, coord=None, name=None, state=None): self._name = name
# Define enviroments, object from LoggerClass import Logger from Position_manager import Position_manager import random from Coordinate import Coordinate from Automa import Automa # LOGGING -- logger = Logger(module_name=__name__, class_name='World') # Enviroments # METHODS -- def createEnviroment(name='default_env', limits=[100, 100, 10]): return Position_manager(name, limits) def createObstacles(): pass def createResourceObject(num=300): """Create and position Resource Object into enviroments""" # resource_types = ('ORGANIC', 'GAS', 'PLASMA', ...) # for i in range(num): #res_typ = resource_types[range.randint( 0, len(resource_types) ) ]
# some_file.py import sys # insert at 1, 0 is the script path (or '' in REPL) sys.path.insert(1, 'project') from State import State from Sensor import Sensor from Sensibility import Sensibility from Position_manager import Position_manager from Object import Object from LoggerClass import Logger # LOGGING -- logger = Logger(module_name=__name__, class_name='Sensor_test') def testClassSensor(): result = True sensor = Sensor(position=(0, 0, 0), range_max=(10, 10, 10), typ="thermal") if sensor._position != ( 0, 0, 0 ) or not sensor._sensibility or not isinstance( sensor._sensibility, Sensibility ) or sensor._power != 100 or sensor._resilience != 100 or not sensor._name or not sensor._state or not sensor._type or sensor._type != 'thermal': print('Sensor Failed!! ', sensor._sensibility, sensor._power, sensor._resilience) result = False
import random from Coordinate import Coordinate import General from State import State from Event import Event from LoggerClass import Logger # LOGGING -- logger = Logger(module_name=__name__, class_name='Actuator') class Actuator: #position, range_max, typ, emissivity_perception = 1, power = 100, resilience = 100, delta_t = 0.01, accuracy = 5, name = None, state = None def __init__(self, position, range_max, class_, typ, power=100, resilience=100, delta_t=0.01, name=None): if not self.checkParam(position, class_, typ, range_max, power, resilience, delta_t): raise Exception("Invalid parameters! Actuator not istantiate.") self._name = name self._id = General.setId('Actuator_ID', None) # Id generator automaticamente
from Coordinate import Coordinate import General from State import State from LoggerClass import Logger # LOGGING -- logger = Logger(module_name = __name__, class_name = 'Action') class Action: def __init__( self, typ, time2go = 1, duration = 1, position = None, obj = None, param = None ): if not self.checkParam(typ, time2go, duration ): raise Exception("Invalid parameters! Action not istantiate.") self._type = typ # type: ACTION_TYPE = ( "move", "run", "take", "catch", "eat", "attack", "escape", "nothing", "shot", "hit" ) self._id = General.setId(self._type, None) # l'id viene generato automaticamente nel runtime per ogni istanza creata self._time2go = time2go self._duration = duration self._position = position self._object = obj self._param = param def decrTime2Go( self ): self._time2go = self._time2go -1 return self._time2go def decrDuration( self ):
from LoggerClass import Logger import General import math # LOGGING -- logger = Logger(module_name=__name__, class_name='Sensibility') class Sensibility: def __init__(self, max_range, accuracy=5, type_space='TETRAHEDRIC'): if not self.checkParam(max_range, type_space): raise Exception("Invalid parameters! Sensibility not istantiate.") self._type_space = type_space self._max_range = max_range self._accuracy = accuracy def checkParam(self, max_range, type_space): if not max_range or not General.checkDimension( max_range) or type_space != 'TETRAHEDRIC': return False return True # tets: ok def get_probability_of_perception(self, start_percept_position): if self._type_space == 'TETRAHEDRIC': return self.get_tetrahedric_probability(start_percept_position, self._accuracy)
from UtilityClass import Utility from LoggerClass import Logger from PropertiesFileManagerClass import PropertiesFileManager import ConfigParser import copy from ete2 import Tree """ 1. Configuration and declaration Read properties files from propertiesFilemanager class Declaration of logging """ propertiesFile = PropertiesFileManager() propertiesFile.readPropertiesFile() Logger.init(propertiesFile.logFile,propertiesFile.logLevel) logger = logging.getLogger() disk_count=int(input("How many disks ? ")) init = ResolutionHanoi(disk_count) iDisk=init.initDisk() # initialisation n diks and 3 lods lDisk=init.destinationDisk() # rules = RuleHanoi(iDisk) tree={} treeAndValues={} treeAndValues[1]=iDisk treeCheck={} treeCheck[1]=True
from Coordinate import Coordinate import General from LoggerClass import Logger # LOGGING -- logger = Logger(module_name = __name__, class_name = 'Threat') class Threat: # non puoi utilizzare un riferimento ad un obj in quanto ti crea l'errore per riferimento circolare (Object import General import AI import Threat import Object [java non ha questo problema]) # quindi devi definire qui tutte le caatteristiche necessarie della Threat per essere elaborata dalla AI def __init__( self, level, name = None, id = None ): if not( level ): raise Exception("Invalid parameters! Threat not istantiate.") self._name = None self._id = None if not name: self._name = General.setName('Threat_Name') else: self._name = name if not id: self._id = General.setId('Threat_ID') else:
# non puoi utilizzare un riferimento ad un obj in quanto ti crea l'errore per riferimento circolare (Object import General import AI import Threat import Object [java non ha questo problema]) # quindi devi definire qui tutte le caatteristiche necessarie della Threat per essere elaborata dalla AI from State import State from LoggerClass import Logger # LOGGING -- logger = Logger(module_name=__name__, class_name='Obstacle') class Obstacle: def __init__(self, coord, type='WATER_STONE', name='Stone', dimension=[1, 1, 1]): self._type = type #WATER_STONE, ENERGY_FIELD, ...... # La water stone rappresenta un volume d'acqua fermo o mobile che non può essere attraversato
from State import State from Automa import Automa from Sensor import Sensor from Actuator import Actuator from Coordinate import Coordinate from Position_manager import Position_manager from Object import Object from Event import Event from Action import Action from LoggerClass import Logger # LOGGING -- logger = Logger(module_name=__name__, class_name='Automa_test') def testClassAutoma(): result = True message = 'MESSAGE: ' # actuator(position, range_max, typ, power = 100, resilience = 100, delta_t = 0.01, name = None, state = None) #name = 'Automa', dimension = [1, 1, 1], resilience = 10, state = State(run = True), ai = AI(), coord = None, sensors= None, actuators = None coord = Coordinate(0, 0, 0) sensors = [ Sensor(typ="radio", position=coord.getPosition(), range_max=(100, 100, 100)), Sensor(typ="optical", position=coord.getPosition(),
from State import State from Threat import Threat from Resource import Resource from Obstacle import Obstacle from Action import Action import General from LoggerClass import Logger # LOGGING -- logger = Logger(module_name = __name__, class_name = 'AI') class AI: # La AI è deputata esclusivamente alla valutazione delle informazioni ricevute dai sensori per # l'aggiornamento dello stato dell'automa e del enviroment conosciuto dall'automa (env_state) # e per definire l'azione da compiere in base a queste informazioni def __init__(self, state = State(run = True), env_state = None ): self._state = state #Class State self._env_state = env_state if not self.checkProperty(): raise Exception("Invalid parameters! Object not istantiate.") logger.logger.debug('AI Instantiate') # Methods
# Automa from Object import Object from State import State from Actuator import Actuator from Sensor import Sensor from AI import AI import General from Event import Event from Action import Action from LoggerClass import Logger import random # LOGGING -- logger = Logger(module_name=__name__, set_consolle_log_level=30, set_file_log_level=10, class_name='Automa') class Automa(Object): """Automa derived from Object. """ # TEST: OK def __init__( self, name='Automa', dimension=[1, 1, 1], mass=100, maxLoad=500, resilience=100, power=100,
from Coordinate import Coordinate import General from State import State from LoggerClass import Logger # LOGGING -- logger = Logger(module_name=__name__, class_name='Event') class Event: def __init__(self, typ, time2go=1, duration=1, volume=None, energy=None, power=None, mass=None): if not self.checkParam(typ, volume, time2go, duration, energy, power, mass): raise Exception("Invalid parameters! Event not istantiate.") self._type = None # type: HIT, PUSH, POP, ASSIMILATE, MOVE self._id = General.setId( self._type, None ) # l'id viene generato automaticamente nel runtime per ogni istanza creata self._volume = volume # volume coinvolto dall'evento self._time2go = time2go # il tempo di attesa (in task o cicli) per considerare gli effetti dell'evento. time2go = 0 -> valutazione effetti evento self._duration = duration # la durata (in task o cicli) dell'evento. duration = 0 -> evento concluso
import Coordinate from LoggerClass import Logger import General # LOGGING -- logger = Logger(module_name=__name__, class_name='Resource') class Resource(): def __init__(self, obj, type='FOOD', name=None): if not (type and obj): raise Exception("Invalid parameters! Resource not istantiate.") self._name = None self._id = None if not name: self._name = General.setName('Threat') else: self._name = name if not id: self._id = General.setId('Threat') else: self._id = id self._type = type #FOOD, WATER, ENERGY, .... self.obj = obj