class AbalonePrologAIEngine(object):
# loads the abalone.pl prolog file
def __init__(self):
self.swipl = Prolog()
self.swipl.consult("./abalone.pl")
result = list(self.swipl.query("start_game"))
if not result:
raise Exception('Error in initializing the game')
# make_move
# @color - the color of the current player
# @from_cell - the beginning cell of the move
# #end_cell - the end cell of the move
# execute in prolog:
# can_make_move query for validation the move is valid
# make_move query for executing the move in prolog.
# returns tuple of the MoveType and Move Direction
def make_move(self, color, from_cell, to_cell='not_exist'):
result = list(self.swipl.query(
"can_make_move(MoveType, %s, Direction, %s, %s), "
"make_move(MoveType, %s, Direction, %s, %s)" % (
color, from_cell, to_cell, color, from_cell, to_cell)))
if not result:
return None, None
return PROLOG_MOVES_TO_PUSH_TYPE[str(result[0]['MoveType'])], result[0]['Direction']
# make_move
# @color - the color of the current player
# execute in prolog:
# get_best_move query for getting the computer best move
# make_move query for executing the move in prolog.
# returns tuple of the MoveType, Move Direction, FromCell, EndCell
def get_best_move(self, color):
result = list(self.swipl.query(
"get_best_move(%s, MoveType, Direction, From, To)" % color))
if not result:
return None, None, None, None
query = "make_move(%s, %s, %s, %s, %s)" % (
(result[0]['MoveType']), color, result[0]['Direction'], result[0]['From'], result[0]['To'])
result2 = list(self.swipl.query(query))
if not result2:
print('unexpected error')
return PROLOG_MOVES_TO_PUSH_TYPE[str(result[0]['MoveType'])], result[0]['Direction'], \
result[0]['From'], result[0]['To']
def change_level(self, level):
self.swipl.retract("level(OldLevel)" )
self.swipl.asserta('level(%s)' % level)
# get_current_score
# execute in prolog
# game_score query for getting the current game score
# returns tuple of the number of white cells, blackcells, and weather the game ended.
def get_current_score(self):
result = list(self.swipl.query("game_score(Black, White, Victory)"))
return result[0]['White'], result[0]['Black'], result[0]['Victory']
class PrologPhoneChoiceAssistant(PhoneChoiceAssistant):
_REQUIRE_TEMPLATE = "user_requirement({rule_key}, {value})"
def __init__(
self,
rules_file: str,
knowledge_base_file: str,
):
super().__init__()
self._prolog = Prolog()
self._load_knowledge_base(knowledge_base_file)
self._load_rules(rules_file)
self._loaded_rules: Dict[RuleKey, Rule] = dict()
def _load_rules(
self,
rules_file: str,
):
self._prolog.consult(rules_file)
def _load_knowledge_base(
self,
knowledge_base_file: str,
):
self._prolog.consult(knowledge_base_file)
def suggest(self) -> Set[Model]:
models: Generator[Dict[str, bytes], None,
None] = self._prolog.query("is_sufficient(Model)")
models_list = [d["Model"].decode("utf-8") for d in models]
return set(models_list)
def battery_life(self, battery_life: BatteryLife):
rule_key = "battery_life"
self._require(rule_key, battery_life.name.lower())
def cpu_frequency(self, cpu_frequency: CPUFrequency):
rule_key = "cpu_frequency"
self._require(rule_key, cpu_frequency.name.lower())
def touch_screen(self):
rule_key = "touch_screen"
self._require(rule_key, RequiredFeature_String)
def nfc(self):
rule_key = "nfc"
self._require(rule_key, RequiredFeature_String)
def water_resistant(self):
rule_key = "touch_screen"
self._require(rule_key, RequiredFeature_String)
def dual_sim(self):
rule_key = "dual_sim"
self._require(rule_key, RequiredFeature_String)
def cpu_n_cores(self, cpu_n_cores: CpuNCores):
rule_key = "cpu_n_cores"
self._require(rule_key, cpu_n_cores.name.lower())
def back_camera_matrix(self, back_camera_matrix: BackCameraMatrix):
rule_key = "back_camera_matrix"
self._require(rule_key, back_camera_matrix.name.lower())
def front_camera_matrix(self, front_camera_matrix: FrontCameraMatrix):
rule_key = "front_camera_matrix"
self._require(rule_key, front_camera_matrix.name.lower())
def phone_for_business(self):
rule_key = "phone_for_business"
self._require(rule_key, RequiredFeature_String)
def big_screen(self):
rule_key = "big_screen"
self._require(rule_key, RequiredFeature_String)
def very_big_screen(self):
rule_key = "very_big_screen"
self._require(rule_key, RequiredFeature_String)
def phone_for_teenager(self):
rule_key = "phone_for_teenager"
self._require(rule_key, RequiredFeature_String)
def phone_to_listening_music(self):
rule_key = "phone_to_listening_music"
self._require(rule_key, RequiredFeature_String)
def phone_for_social_media(self):
rule_key = "phone_for_social_media"
self._require(rule_key, RequiredFeature_String)
def phone_to_play_games(self):
rule_key = "phone_to_play_games"
self._require(rule_key, RequiredFeature_String)
def phone_to_make_photos(self):
rule_key = "phone_to_make_photos"
self._require(rule_key, RequiredFeature_String)
def phone_for_trips(self):
rule_key = "phone_for_trips"
self._require(rule_key, RequiredFeature_String)
def _require(self, rule_key: str, value: Any):
previous_rule = self._loaded_rules.get(rule_key)
if previous_rule:
self._prolog.retract(previous_rule)
new_rule = PrologPhoneChoiceAssistant._REQUIRE_TEMPLATE.format(
rule_key=rule_key,
value=value,
)
print(new_rule)
self._prolog.asserta(new_rule)
self._loaded_rules[rule_key] = new_rule
def clear_requirements(self):
self._prolog.retractall("user_requirement(A,B)")
self._loaded_rules = dict()
class Game():
def __init__(self,radius=80):
self.win = Tk()
self.radius = radius
self.pawnList1 = []
self.pawnList2 = []
self.generatePawns()
self.playerOne = True
self.pawnSelected = False
self.chaining = False
self.capturing = False
self.selectedPawn = None
self.captured = None
self.prolog = Prolog()
self.prolog.consult("clauses.pl")
self.prolog.asserta("hos(dummy)")
self.defaultPosition()
self.board = Board(self.pawnList1,self.pawnList2,self.radius,self.win,self)
self.board.mainloop()
def getPawnByName(self,name):
for p in self.pawnList1:
if p.getName() == name:
return p
for p in self.pawnList2:
if p.getName() == name:
return p
def checkMove(self,pos):
validMoveQuery = "canMove("+self.selectedPawn.getName()+",NewPos)"
l = list(self.prolog.query(validMoveQuery))
validMoves = []
for i in l:
validMoves.extend(i.values())
if pos in validMoves:
return True
else:
return False
def queryCapturing(self,p):
capturingQuery = "canEat("+p.getName()+",Target,NewPos)"
l = list(self.prolog.query(capturingQuery))
posAfterCapturing = []
for i in l:
posAfterCapturing.extend(i.values())
return posAfterCapturing
def checkCapturing(self,pos):
posAfterCapturing = self.queryCapturing(self.selectedPawn)
if pos in posAfterCapturing:
self.captured = self.getPawnByName(posAfterCapturing[posAfterCapturing.index(pos)+1])
self.capturing = True
return True
else:
return False
def defaultPosition(self):
positions = ["position(a1,60)",
"position(b1,71)",
"position(c1,62)",
"position(d1,73)",
"position(e1,64)",
"position(f1,75)",
"position(g1,66)",
"position(h1,77)",
"position(a2,00)",
"position(b2,11)",
"position(c2,02)",
"position(d2,13)",
"position(e2,04)",
"position(f2,15)",
"position(g2,06)",
"position(h2,17)"]
for position in positions:
self.prolog.asserta(position)
#for pos in self.prolog.query("position(X,Y)"):
#print pos["X"], pos["Y"]
def modifyPosition(self):
for position in self.prolog.query("retractall(position(_,_))"):
pass
for pawn in self.pawnList1:
self.prolog.asserta(
"position(" + pawn.getName() + "," +
str(pawn.getRow()) + str(pawn.getColumn()) + ")")
for pawn in self.pawnList2:
self.prolog.asserta(
"position(" + pawn.getName() + "," +
str(pawn.getRow()) + str(pawn.getColumn()) + ")")
def generatePawns(self):
for i in range(8):
name = chr(97+i)
self.pawnList1.append(Pawn(name+"1", 6 + (i % 2), i, 'blue', self.radius))
self.pawnList2.append(Pawn(name+"2", 0 + (i % 2), i, 'red', self.radius))
def selectPawn(self,p):
self.pawnSelected = True
self.selectedPawn = p
# self.board.highlightPawn(p)
def unselectPawn(self):
self.pawnSelected = False
# self.board.drawPawn(self.selectedPawn)
self.selectedPawn = None
def addHos(self, pawn):
self.prolog.asserta("hos("+pawn.getName()+")")
def checkHos(self,pawn):
if pawn in self.pawnList1:
if pawn.row == 0:
if pawn.hos is not True:
pawn.hos = True
self.addHos(pawn)
elif pawn in self.pawnList2:
if pawn.row == 7:
if pawn.hos is not True:
pawn.hos = True
self.addHos(pawn)
def punish(self):
if self.playerOne:
for p in self.pawnList1:
if len(self.queryCapturing(p)) > 0:
self.deletePawn(p)
break
else:
for p in self.pawnList2:
if len(self.queryCapturing(p)) > 0:
self.deletePawn(p)
break
def move(self, pos):
if self.checkCapturing(pos) or self.checkMove(pos):
self.selectedPawn.move(pos // 10, pos % 10)
if self.capturing:
self.deletePawn(self.captured)
moved = True
else:
moved = False
if moved:
if not self.capturing:
self.punish()
self.checkHos(self.selectedPawn)
self.chaining = True
self.modifyPosition()
if self.selectedPawn == None or (len(self.queryCapturing(self.selectedPawn)) == 0 and self.capturing or not self.capturing):
self.playerOne = not self.playerOne
self.chaining = False
self.capturing = False
self.captured = None
self.botPlays()
'''print "---------"
for pos in self.prolog.query("position(X,Y)"):
print pos["X"], pos["Y"]
print "-------------------------------"
for hos in self.prolog.query("hos(X)"):
print hos["X"]'''
def deletePawn(self, pawn):
if pawn in self.pawnList1:
self.pawnList1.remove(pawn)
else:
self.pawnList2.remove(pawn)
self.board.deletePawn(pawn)
if pawn == self.selectedPawn:
self.selectedPawn = None
def generateStates(self):
lst = []
for pos in self.prolog.query("position(X,Y)"):
#print pos["X"]
lst.append([pos["X"], pos["Y"]])
return lst
def generateHoses(self):
lst = []
for pos in self.prolog.query("hos(X)"):
#print pos["X"]
lst.append(pos["X"])
return lst
def botPlays(self):
s = str(self.generateStates())
s = s.replace("'",'')
h = str(self.generateHoses())
h = h.replace("'",'')
states = []
for res in self.prolog.query("minimax("+s+","+h+",NewStates)"):
states.append(res["NewStates"])
#for res in self.prolog.query("minimaxVal(_,1,States)"):
# states.append(res["States"])
states = states[0]
for i in range(len(states)):
states[i][0] = str(states[i][0])
'''for i in range(len(self.pawnList1)):
pawn = self.pawnList1[i]
pos = states[i][1]
if states[i][0] == pawn and states[i][1] != pawn.row*10+pawn.col:
self.board.deletePawn(pawn)
self.selectedPawn.move(pos // 10, pos % 10)
self.board.drawPawn(pawn)'''
for i in range(len(self.pawnList2)):
pawn = self.pawnList2[i]
pos = states[i][1]
for j in range(len(states)):
if states[j][0] == pawn.name and states[j][1] != pawn.row*10+pawn.col:
self.board.deletePawn(pawn)
pawn.move(states[j][1]//10, states[j][1]%10)
self.board.drawPawn(pawn)
for i in range(len(states)):
states[i] = states[i][0]
for pawn in self.pawnList1:
if pawn.name not in states:
self.pawnList1.remove(pawn)
self.board.deletePawn(pawn)
for pawn in self.pawnList2:
if pawn.name not in states:
self.pawnList2.remove(pawn)
self.board.deletePawn(pawn)
self.modifyPosition()
self.playerOne = not self.playerOne
# inicializa a ligacao ao prolog
prolog = Prolog()
prolog.consult("base.pl")
prolog.consult(sys.argv[1] + ".pl")
profundidade = 0
# argumento 2 (primeiro ou segundo)
if (sys.argv[2] != "p" and sys.argv[2] != "-p" and sys.argv[2] != "s"
and sys.argv[2] != "-s"):
print("Argumentos errados: -p / -s")
exit(1)
primeiro = (sys.argv[2] == "p" or sys.argv[2] == "-p")
if primeiro:
prolog.asserta("jogador(p1)")
prolog.consult("1.pl") #regras para o jogador 1
else:
prolog.asserta("jogador(p2)")
prolog.consult("2.pl") #regras para o jogador 2
# argumento 3 (nivel)
"""
if(sys.argv[3] != "1" and sys.argv[3] != "2" and
sys.argv[3] != "3"):
print("Argumentos errados: 1 / 2 / 3")
exit(1)
if(sys.argv[3] == "1"):
prolog.asserta("profundidade(%d)" %(7))
elif(sys.argv[3] == "2"):
prolog.asserta("profundidade(%d)" %(8))
class CovidAIBrigde:
"""
Communicates directly with prolog scripts to return diagnosis
"""
def __init__(self, name, log=False):
self.prolog = Prolog()
self.patient_name = name.split(" ")[0].lower()
self.log = log
self.prolog.consult('covid.pl')
def store_home_parish(self, parish):
"""
Store the patient current home parish
Parameters:
parish(list): What symptoms does the patients
"""
parish = parish.lower()
if "st." in parish:
parish = parish.split(" ")
parish[0] = "saint"
parish = "_".join(parish)
query_string = f"from_parish({self.patient_name}, {parish})"
self.prolog.asserta(query_string)
if self.log:
self.__log_function(query_string)
def store_symptoms(self, symptoms):
"""
Store the patient symptoms
Parameters:
symptoms(list): What symptoms does the patients
"""
query_strings = [
f"has_symptom({self.patient_name}, '{symptom}')"
for symptom in symptoms
]
for query_string in query_strings:
self.prolog.asserta(query_string)
if self.log:
for query_string in query_strings:
self.__log_function(query_string)
def store_temperature(self, temperature):
"""
Store the patient temperature
Parameters:
temperature(int): What is the patients temperature
"""
query_string = f"patient_temperature({self.patient_name}, {temperature})"
self.prolog.asserta(query_string)
if self.log:
self.__log_function(query_string)
def store_patient_activities(self, wm, t, s, p):
"""
Store the patient activities that could contribute to diagnosis
Parameters:
wm(str): Does the patient usually wear a mask
t(str): Does the patient travel alot
s(str): Does the patient sanitize regularly
p(str): Does the patient go to parties
"""
query_string_mask = f"wears_mask({self.patient_name}, {wm.lower()})"
query_string_travel = f"travels({self.patient_name}, {t.lower()})"
query_string_sanitize = f"sanitizes({self.patient_name}, {s.lower()})"
query_string_party = f"goes_parties({self.patient_name}, {p.lower()})"
self.prolog.asserta(query_string_mask)
self.prolog.asserta(query_string_travel)
self.prolog.asserta(query_string_sanitize)
self.prolog.asserta(query_string_party)
if (self.log):
self.__log_function(query_string_mask)
self.__log_function(query_string_travel)
self.__log_function(query_string_sanitize)
self.__log_function(query_string_party)
def diagnose(self):
"""
Diagnosis and returns a value for how much the chances this patient has covid
"""
results = list(self.prolog.query(f"has_covid({self.patient_name}, X)"))
return results[0]
def __log_function(self, string):
"""
prints out any string passed in with specific format
"""
print(f"I KNOW: {string}.")
def memory_wipe(self):
"""
wipe information about patient from the agents memory
"""
# define predicate strings
query_string_symptom = f"has_symptom({self.patient_name},_)"
query_string_parish = f"from_parish({self.patient_name},_)"
query_string_temp = f"patient_temperature({self.patient_name},_)"
query_string_mask = f"wears_mask({self.patient_name},_)"
query_string_travel = f"travels({self.patient_name},_)"
query_string_sanitize = f"sanitizes({self.patient_name},_)"
query_string_party = f"goes_parties({self.patient_name},_)"
self.prolog.retractall(query_string_symptom)
self.prolog.retract(query_string_parish)
self.prolog.retract(query_string_temp)
self.prolog.retract(query_string_mask)
self.prolog.retract(query_string_travel)
self.prolog.retract(query_string_sanitize)
self.prolog.retract(query_string_party)
def __open_db_connection(self):
"""
Open connection to database
"""
try:
self.con = sqlite3.connect("covidAi.db")
print("[Connection established]")
except Error:
print(Error)
def __get_parish_statistics(self):
cursorObj = self.con.cursor()
cursorObj.execute("SELECT * FROM parishes")
rows = list(cursorObj.fetchall())
return rows
def update_knowledgebase(self):
self.__open_db_connection()
statistics = self.__get_parish_statistics()
for (id, parish, chance) in statistics:
parish_assersion = f"covid_cases({parish}, {chance})"
print(parish_assersion)
self.prolog.asserta(parish_assersion)
