def get_player_party(self, count=3):
"""Return player party."""
ui = self.ui
party = []
for i in range(1, count + 1, 1):
charName = input(f"Enter player {i} Name:")
if len(charName) <= 0:
ui.print_error("You must enter at least 1 character")
else:
# Create party member
mbr = Person({
"name": charName,
"hp": 500,
"mp": 70,
"attack": 45,
"defense": 40,
"spells": self.spellList
})
mbr.action = ["Attack", "Magic", "Item"]
# Fill party mbr's inventory
for item in self.itemList:
mbr.add_item(item, 5)
# Add party mbr to player party
self.add_party_member(party, mbr)
return party
def test_ui_print_hpmp(self):
"""ui.print_hpmp prints to a string console."""
def write(value):
return value
player = Person("test0", 200, 100, 10, 10, [], [])
enemy = Person("test1", 200, 100, 10, 10, [], [])
self.assertEqual(type(self.ui.print_hpmp(player, enemy, write)), str,
"Does not print a string.")
def init_town(self):
solo_key = 0
random.seed()
for home in self.city.get_houses():
inhabitants = []
chance = random.random()
# matrimony
if chance < 0.6:
# ages
wife_age = random.randrange(14, 28)
husband_age = random.randrange(18, 38)
# keys & people
w, h = "{}a".format(self.total_marriages), "{}b".format(
self.total_marriages)
wife = Person(None,
w,
self,
house=home,
sex='f',
age=wife_age,
married=True,
emancipated=True,
independent=True)
husband = Person(None,
h,
self,
house=home,
sex='m',
age=husband_age,
married=True,
emancipated=True,
independent=True)
self.marry(wife, husband, assigned_home=home)
# roommates
elif chance < 0.8:
no_inhabitants = random.randint(2, 5)
age_lowest = random.randrange(15, 50)
sex = 'f' if random.random() < 0.4 else 'm'
for _ in range(no_inhabitants):
age = random.randint(age_lowest, age_lowest + 10)
key = "{}s".format(solo_key)
inhabitant = Person(None,
key,
self,
house=home,
sex=sex,
age=age)
inhabitants.append(inhabitant)
solo_key += 1
home.add_people(inhabitants)
def populate(self):
# Create people
building_capacity = (
FLOORS -
1) * FLOOR_CAPACITY # -1 because floor 0 is not a valid home floor
people_slots = random.sample(
range(building_capacity),
math.ceil(building_capacity * BUILDING_FULLNESS))
for ps in people_slots:
home_floor = math.floor(
ps /
FLOOR_CAPACITY) + 1 # +1 because 0 is not a valid home floor
entry_time = MEAN_ENTRY_TIME + timedelta(
minutes=np.random.normal(0, 30))
to_lunch_time = MEAN_TO_LUNCH_TIME + timedelta(
minutes=np.random.normal(0, 30))
from_lunch_time = to_lunch_time + timedelta(
minutes=MEAN_LUNCH_TIME) + timedelta(
minutes=np.random.normal(0, 5))
leave_time = MEAN_LEAVE_TIME + timedelta(
minutes=np.random.normal(0, 30))
self.people.append(
Person(ps, home_floor, entry_time, to_lunch_time,
from_lunch_time, leave_time))
def updateRecord(db, form):
# try:
# key = form['key']
# record = db[key]
# for field in record:
# record[field] = form[field]
# fields = record.__dict__
# fields['key'] = key
# except:
# fields = dict.fromkeys(fieldnames, '?')
# fields['key'] = 'Missing a key or just the record doesn\'t exist. You can try an another key.'
if not 'key' in form:
fields = dict.fromkeys(fieldnames, '?')
fields['key'] = 'Missing key input.'
else:
key = form['key'].value
if key in db:
record = db[key] # изменить существующую запись
else:
#from sys.modules import db # создать/сохранить новую
from classes.person import Person # создать/сохранить новую
record = Person(name='?', age='?') # eval: строки должны быть
# заключены в кавычки
for field in fieldnames:
setattr(record, field, eval(repr(form[field].value)))
db[key] = record
fields = record.__dict__
fields['key'] = key
return fields
def write_people_db(list_name, list_2, credentials=CREDENTIALS):
people_1 = []
people_2 = []
for obj in list_2:
people_2.append(obj.drink_id)
counter = 0
connection = pymysql.connect(**credentials)
cursor = connection.cursor()
cursor.execute("SELECT person_name, age, favourite_drink_id FROM person")
rows = cursor.fetchall()
for row in rows:
person = Person(row[0], row[1])
people_1.append(person)
for person in list_name:
counter += 1
person_found = False
for person_1 in people_1:
if person.name == person_1.name:
person_found = True
if person_found == False:
connection = pymysql.connect(**credentials)
cursor = connection.cursor()
cursor.execute(
f"INSERT INTO person(person_name, age, favourite_drink_id) values ('{person.name}', '{person.age}', '{people_2[counter-1]}')"
)
connection.commit()
def get_enemy_party(self, count=3):
"""Return ."""
party = []
for i in range(1, count + 1, 1):
enemy = Person({
"name": f"S******d {i}",
"hp": 500,
"mp": 70,
"attack": 45,
"defense": 40,
"spells": self.spellList
})
enemy.action = ["Attack", "Magic", "Item"]
for item in self.itemList:
enemy.add_item(item, 5)
self.add_party_member(party, enemy)
return party
def read_database_people(list_name, credentials=CREDENTIALS):
connection = pymysql.connect(**credentials)
cursor = connection.cursor()
cursor.execute("SELECT person_name, age, favourite_drink_id FROM person")
rows = cursor.fetchall()
for row in rows:
person = Person(row[0], row[1])
list_name.append(person)
cursor.close()
connection.close()
return list_name
def main():
# Create an empty array.
PersonList = []
# Create some objects from the Person class
person1 = Person(input('Enter a persons name: '))
person2 = Person(input('Enter a persons name: '))
person3 = Person(input('Enter a persons name: '))
# Add each person object to the PersonList array
PersonList.append(person1)
PersonList.append(person2)
PersonList.append(person3)
# Check the length of the array. str() converts the number to a string
print('The length of the array is: ' + str(len(PersonList)))
# Get the name of the people we just created using a for loop and calling
# the getName method from the Person class
for items in PersonList:
print(items.name)
def create_players(enemy_names):
"""Create players - humans and computers"""
while True:
man_vs_bot = Game.choose_mode(
) # True if in mode players vs computers
num_player = input(
colored("Number of players (1-5, or * to go back): ",
color=Color.command))
if num_player == '*' or not_number(num_player):
continue
Database.num_player = int(num_player)
if Database.num_player > 5 or Database.num_player < 1:
print(
"The game can only have 1-5 players. Please enter the number of players again.\n"
)
continue
break
print("Please enter the name(s) of player(s)")
for i in range(Database.num_player):
text = colored(f"Player {i + 1}: ", Color.command)
if man_vs_bot: # Players vs computers mode
Database.players.append(
Person(name=input(text).capitalize(), human_mode=True))
else: # Player + computer vs computers mode
if i == 0:
Database.players.append(
Person(name=input(text).capitalize(), human_mode=True))
elif i > 0:
Database.players.append(
Person(
name=input(text).capitalize(),
human_mode=False,
human_team=True,
))
Database.computers.append(
Person(name=enemy_names[i], human_mode=False,
human_team=False))
def _cam_humans_2_person_list(self, humansFromCam):
new_person_list = []
for cam_person in humansFromCam.humanList:
detected_person = Person()
#TODO: is the camera id the one we assume for the person? How we update this?
detected_person.person_id = cam_person.id
detected_person.confidence = cam_person.confidence
detected_person.cameras.append(humansFromCam.idCamera)
detected_person.initialice_tracker(
Position2D(cam_person.pos.x, cam_person.pos.z))
new_person_list.append(detected_person)
return new_person_list
def setup(cls, people_count, grid_width, grid_height):
'''constructs an instance of Simulator'''
# construct grid and gateway
cls.grid = Grid(grid_width, grid_height)
cls.gateway = Gateway()
# construct arbitrary luminaire grid
cls.luminaires = []
(grid_height, grid_width) = cls.grid.get_dimensions()
lum_no = 0
for x in range(1, grid_height - 1, 2):
for y in range(1, grid_width - 1, 2):
# generate name for the luminaire
lum_name = 'lum' + str(lum_no)
lum = Luminaire(x, y, lum_name)
cls.luminaires.append(lum)
lum_no = lum_no + 1
# construct people and place them randomly
cls.people = []
for count in range(people_count):
person_x = randint(0, grid_height - 1)
person_y = randint(0, grid_width - 1)
person = Person(person_x, person_y)
cls.people.append(person)
# add luminaires to grid, gateway
for luminaire in cls.luminaires:
cls.grid.add_luminaire(luminaire)
cls.gateway.add_luminaire(luminaire)
# start event listener
cls.gateway.start_gateway_thread()
# add people to grid
for person in cls.people:
cls.grid.add_person(person)
cls.grid.track_people()
def register_page_config(request):
if request.method == 'GET':
listTitle = GetTitleList()
listAccount = GetAccountTypeList()
return render_template('register.html', listTitle=listTitle, listAccount=listAccount, info=' ')
else:
if 'register' in request.form:
PersonProvider = person_operations()
first_name = request.form['firstName']
last_name = request.form['lastName']
eMail = request.form['eMail']
p = PersonProvider.GetPerson(eMail)
error = "'"+eMail+"'" + ' is already in use. Do you forget your password?'
if p is not None:
listTitle = GetTitleList()
listAccount = GetAccountTypeList()
return render_template('register.html', listTitle=listTitle, listAccount=listAccount, info=error)
pswd = pwd_context.encrypt(request.form['pswd'])
accountType = request.form['account']
title = request.form['title']
file = request.files['file']
gender = request.form['r1']
if gender == 'male':
gender = False
elif gender == 'female':
gender = True
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join('static/user_images', filename))
else:
if gender == 'male':
filename = 'noimage_male.jpg'
else:
filename = 'noimage_female.jpg'
p = Person(None, first_name, last_name, accountType, eMail, pswd, gender, title, filename, False)
u = User(eMail, pswd)
PersonProvider.AddPerson(p)
AddUser(u)
return redirect(url_for('site.login_page', info=' '))
def recursive_camera_clique(self, cameras_data_array):
cam_pairs = chunks(cameras_data_array, 2)
new_camera_array = []
for pair in cam_pairs:
if len(pair) == 2:
# create virtual cam with all the persons from both cams
virtual_cam = CameraFrame()
# calculate mathing persons with click
humans1 = pair[0].person_list
humans2 = pair[1].person_list
virtual_human_list = humans1 + humans2
max_clique, matching_graph = calculate_clique_matching(
humans1, humans2)
for node_id in max_clique:
if node_id in matching_graph.nodes:
node = matching_graph.nodes[node_id]
first_person = node["person1"]
second_person = node["person2"]
logger.debug(
"Node %s relates %d in with %d. Merging positions (%d, %d) to (%d, %d)",
node_id, first_person.person_id,
second_person.person_id, first_person.pos.x,
first_person.pos.y, second_person.pos.x,
second_person.pos.y)
new_person = Person.merge(first_person, second_person)
# new_person.color =
if first_person in virtual_human_list:
virtual_human_list.remove(first_person)
if second_person in virtual_human_list:
virtual_human_list.remove(second_person)
virtual_human_list.append(new_person)
virtual_cam.person_list = virtual_human_list
new_camera_array.append(virtual_cam)
else:
new_camera_array.append(pair[0])
if len(new_camera_array) > 1:
return self.recursive_camera_clique(new_camera_array)
else:
return new_camera_array[0]
def from_ice_struct(humansFromCam):
# struct humansDetected
# {
# int idCamera;
# long timeStamp;
# personList humanList;
# };
new_camera_frame = CameraFrame()
new_camera_frame.id_camera = humansFromCam.idCamera
new_camera_frame.timestamp = humansFromCam.timeStamp
new_camera_frame.person_list = []
for cam_person in humansFromCam.humanList:
detected_person = Person()
# TODO: is the camera id the one we assume for the person? How we update this?
detected_person.person_id = cam_person.id
detected_person.confidence = cam_person.pos.confidence
detected_person.cameras.append(humansFromCam.idCamera)
detected_person.initialice_tracker(Position2D(cam_person.pos.x, cam_person.pos.z))
new_camera_frame.person_list.append(detected_person)
return new_camera_frame
from classes.person import Person
from classes.computer import Computer
print 'Welcome to four number game!'
print 'Wanna guess a number or let the computer guess?'
try:
option = raw_input('Choose 1 or 2 respectively: ')
if option == '1':
person = Person()
person.begin()
elif option == '2':
computer = Computer()
computer.begin()
else:
print 'Bad option. Try again!'
except KeyboardInterrupt:
print '\nBye'
from classes.student import Student
from classes.person import Person
pappu = Student("Pappu", 7)
print(pappu)
pappu = Student("Pappu", grade=7)
print(pappu)
print(pappu.whoami)
munnu = Person("Munnu")
print(munnu)
print(munnu.name)
print(munnu.whoami)
# print(pappu.name)
import unittest
from classes.person import Person, make_person
class MakePerson(unittest.TestCase):
'''Tests the make person function.'''
def test_store_person(self):
"""Test that a single response is stored properly."""
tests = []
make_person(tests)
for person in tests:
self.assertEqual(person.name, new_person.name)
new_person = Person('bob', 32)
if __name__ == '__main__':
unittest.main()
# get string and make a audio file to be played
def speak(audio_string):
tts = gTTS(text=audio_string, lang='en') # text to speech(voice)
r = randint(1, 20000000)
audio_file = 'audio' + str(r) + '.mp3'
tts.save(audio_file) # save as mp3
# print what app said
print(f"{bcolors.RED}Emma:{bcolors.END} {audio_string}")
playsound(audio_file) # play the audio file
os.remove(audio_file) # remove audio file
# starting point
person_obj = Person()
notification_obj = ToastNotifier()
os.system('color') # makes terminal to recognize the colors
# shows notification of program's activation
notification_obj.show_toast(title="Emma Virtual Assistant",
msg="Emma has activated",
icon_path="favicon.ico",
duration=5)
print(
f"\n{bcolors.RED}Emma:{bcolors.END} How can I help you?") # The first line
playsound(r'sounds\starting_line.mp3') # says "How can I help you"
while (1):
voice_data = record_audio() # get the voice input
}, {
"item": hipotion,
"quantity": 5
}, {
"item": superpotion,
"quantity": 5
}, {
"item": elixer,
"quantity": 2
}, {
"item": grenade,
"quantity": 5
}]
# Initialize players
player1 = Person("Matan", 70, 65, 60, 34, player_spells, player_items)
player2 = Person("Netta", 1500, 65, 60, 34, player_spells, player_items)
player3 = Person("Omer", 2000, 65, 60, 34, player_spells, player_items)
players = [player1, player2, player3]
# Initialize enemies
enemy1 = Person("Enemy1", 1200, 65, 20, 25, player_spells, [])
enemy2 = Person("Enemy2", 1500, 65, 45, 25, player_spells, [])
enemy3 = Person("Enemy3", 1800, 65, 50, 25, player_spells, [])
enemies = [enemy1, enemy2, enemy3]
runnig = True
while runnig:
print('==========================================')
for index, player in enumerate(players):
}, {
"name": "jack",
"value": 10
}, {
"name": "queen",
"value": 10
}, {
"name": "king",
"value": 10
}]
kind = ["Hearts", "Clubs", "Diamonds", "Spades"]
# cards = list(range(1, 53))
cards = Cards(name, kind).shuffle_deck()
player = Person("player", "", 0, 0)
dealer = Person("dealer", "", 0, 0)
print("this is the game of blackjack")
wanna_play = input("do you wanna proceed? (y/n): ")
running = True
cards_value = 0
while running:
dealer.value_sum = 0
dealer.cards_holding = ''
player.value_sum = 0
player.cards_holding = ''
dealers_turn = False
if wanna_play == "y":
def read_from_file_1(file_name, list_name):
with open(file_name, 'r+') as csvfile:
new_thing = csv.reader(csvfile, delimiter= ' ')
for row in new_thing:
person = Person(row[0], row[1])
list_name.append(person)
def test_object_of(self):
obj = Person("first", "last", "SD-ID")
self.assertTrue(type(obj) is Person)
from classes.game import rolar_dados
from classes.game import values_for_enemy
from classes.person import Person
from classes.battle import Battle
# print(rolar_dados(20))
easy = 10 # 3
medium = 15 # 5
hard = 25 # 15
extreme = 40 # 30
boss = 100 # 50
player = Person("Jose Oswaldo", *values_for_enemy(easy))
enemy = Person("Brutus", *values_for_enemy(easy))
battle1 = Battle(player, enemy)
battle1.rounds()
