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)