### 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
