def get(self):
### Session verification code ###
session = get_current_session()
try:
if session['key'] and session['key'] != '':
self.redirect('/dashboard')
except KeyError:
pass
#################################
template_values = {
'pagename': 'main',
}
log = 'disabled'
logQ = Setting.all().filter("name =", 'log').run()
for l in logQ:
log = l.value
template_values['log'] = log
indexset = False
indexsettings = Setting.all().filter("name =", 'index').run()
for indexsetting in indexsettings:
indexset = True
index = indexsetting.value
if indexset == False:
path = os.path.join(os.path.dirname(__file__), 'templates/index.html')
self.response.out.write(template.render(path, template_values))
else:
try:
self.redirect(index)
except UnboundLocalError:
path = os.path.join(os.path.dirname(__file__), 'templates/index.html')
self.response.out.write(template.render(path, template_values))
def __init__(self):
self.screen = pygame.display.set_mode((SCREENWIDTH, SCREENHEIGHT))
pygame.display.set_caption('Screaming Bird')
self.pipegap = 120
self.intro = Intro(self.screen)
self.highScore = HighScore(self.screen)
self.settings = Setting(self.screen)
def main(difficulty):
"""
整个程序是在游戏主循环之前创建好地雷等东西，然后在主循环中修改并更新，只创建了一次。
:return:
"""
# 初始化游戏状态记录类
status = Status()
# 初始化设置
setting = Setting(difficulty, status)
# 选择难度
if difficulty.ctrl_F5_key:
chose_difficulty(status, setting, difficulty)
setting = Setting(difficulty, status)
# 初始化程序界面
screen_main = pygame.display.set_mode(setting.main_window_size)
screen_main.fill(setting.background_color)
ico = pygame.image.load(setting.icon).convert_alpha()
pygame.display.set_icon(ico)
pygame.display.set_caption('扫雷')
# 初始化帧数
fps = pygame.time.Clock()
# 初始化扫雷区域
field = MineField(screen_main, setting)
field.build_me()
# 初始化地雷小方块
blocks = create_blocks(field, screen_main, setting)
# 初始化记录窗口
time_record_window = TimeRecordWindow(setting, field, screen_main, status)
time_record_window.build_me()
time_record_window.update_font()
number_record_window = NumberRecordWindow(setting, field, screen_main,
status)
number_record_window.build_me()
number_record_window.update_font()
# 是否需要加上分辨率不足提示语
if difficulty.display_info.current_w < 1920 and difficulty.display_info.current_h < 1080 and difficulty.very_hard:
build_resolution_ratio_word(screen_main, time_record_window, setting)
# 开始程序主循环
while True:
check_event(blocks, setting, status, difficulty)
if status.F5_key:
break
update_blocks(blocks)
game_over(field, status)
update_record_windows(time_record_window, number_record_window, status)
pygame.display.flip()
fps.tick(setting.fps)
return status
def setUp(self):
super(TestUtils, self).setUp()
setting = Setting()
setting.initialize(os.path.join(current_dir, 'settings.cfg'))
conn = Connection()
conn.connect(setting.config)
# initialize logger
Logger.init(**setting.config.twisted.logging)
# Redis 초기화
self.redis = conn.redis
self.redis.delete('current_post_id')
def run_game():
pygame.init()
settings = Setting()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption('ping pong')
player1 = Player(settings, screen)
player2 = Player(settings, screen)
player2.rect.centerx = player2.screen_rect.right - 30
ball = Ball(settings, screen)
scores = Scoreboard(settings, screen)
while True:
gf.check_events(screen, settings, player1, player2)
player1.update()
player2.update()
gf.update_ball(settings, ball, player1, player2, scores)
gf.update_screen(screen, settings, ball, player1, player2, scores)
def __init__(self):
st = Setting()
self.token = st.get_token()
self.client_id = st.get_client_id()
self.client_secret = st.get_client_secret()
self.bot_id = None
self.slack_client = None
self.chat_bot = ChatBot(
"Fox Bot",
storage_adapter='chatterbot.storage.SQLStorageAdapter',
logic_adapters=[
'chatterbot.logic.MathematicalEvaluation',
'chatterbot.logic.BestMatch',
'chatterbot.logic.TimeLogicAdapter'
],
database_uri='sqlite:///database.sqlite3')
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init()
ai_settings = Setting()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invesion")
# 创建Play按钮
play_button = Button(ai_settings, screen, "Play")
# 创建一艘飞船
ship = Ship(ai_settings, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
aliens = Group()
# 创建存储游戏统计信息的实例，并创建记分牌
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# 创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
# 开始游戏主循环
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button)
# 让最近绘制的屏幕可见
pygame.display.flip()
def run_game():
pygame.init() #初始化pygame
ai_settings = Setting() #创建设置实例
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
#创建实例
play_button = Button(ai_settings, screen, "Play")
ship = Ship(ai_settings, screen)
stats = GameStats(ai_settings)
sb = Scoreboad(ai_settings, screen, stats)
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
#游戏主循环
while 1:
#监控事件，鼠标或键盘
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
#每次都更新飞船的运行状况,更新在飞船实例里
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, stats, screen, sb, ship, aliens,
bullets)
#每次循环都重新绘制屏幕（可以理解为一帧
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
def run_game():
pygame.init()
ai_settings = Setting()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
ship = Ship(ai_settings, screen)
alien = Alien(ai_settings, screen) #ispe shak ha
bullets = Group()
aliens = Group()
pygame.display.set_caption("Alien Invasion")
gf.create_fleet(ai_settings, screen, ship, aliens) #new
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
# bullets.update()
# Get rid of bullets that have disappeared.
# for bullet in bullets.copy():
# if bullet.rect.bottom <= 0:
# bullets.remove(bullet)
# print(len(bullets))
gf.update_bullets(bullets)
gf.update_screen(ai_settings, screen, ship, aliens,
bullets) #ispe shak tha
def __init__(self):
super(Alien, self).__init__()
self.setting = Setting()
self.image = pygame.image.load('img/alien.png')
self.rect = self.image.get_rect()
self.rect.centerx = random.randint(0, 600)
def __init__(self):
pivot = Setting()
pivot.check_settings_file()
handlers = [
(r'/', IndexHandler)
]
settings = {
'debug': pivot.setting('DEBUG'),
'template_path': os.path.join(pivot.root, 'templates'),
'static_path': os.path.join(pivot.root, 'static'),
'candidate': pivot.candidate
}
tornado.web.Application.__init__(self, handlers, **settings)
def run_game():
pygame.init()
setting = Setting()
stats = GameStats(setting)
screen = pygame.display.set_mode((setting.width, setting.height))
pygame.display.set_caption("Alien Invasion")
ship = Ship(screen, setting)
bullets = Group()
aliens = Group() # Alien(setting,screen)
gf.creat_fleet(setting, screen, aliens, ship)
playbutton = Button(screen, setting, 'play')
board = Board(setting, screen, stats)
while True:
gf.check_events(aliens, playbutton, stats, setting, screen, ship,
bullets)
if stats.game_active:
ship.update()
gf.update_bullet(setting, screen, ship, bullets, aliens, board,
stats)
gf.update_aliens(setting, screen, ship, bullets, aliens, stats,
board)
#print(len(aliens))444
gf.update_window(setting, screen, ship, bullets, aliens, playbutton,
stats, board)
def run_game():
# 初始化游戏并创造一个屏幕对象
pygame.init()
ai_settings = Setting()
screen = pygame.display.set_mode((ai_settings.screen_width,ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# 创建一个用于存储游戏统计信息的实例,并创建计分牌
stats = GameStats(ai_settings)
sb = Scporeboard(ai_settings,screen,stats)
# 创建一个play按钮
play_button = Button(ai_settings,screen,"Play")
# 创建一个飞船
ship = Ship(ai_settings,screen)
# 创建一个用于储存子弹的编组
bullets = Group()
aliens = Group()
# 创建外星群
gf.create_fleet(ai_settings,screen,ship,aliens)
# 开始游戏的主循环
while True:
# 监听鼠标和键盘事件
gf.check_events(ai_settings,screen,stats,play_button,ship,aliens,bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings,screen,ship,aliens,bullets)
gf.update_aliens(ai_settings,stats,screen,ship,aliens,bullets)
gf.update_screen(ai_settings,screen,stats,sb,ship,aliens,bullets,play_button)
def run_game():
setting = Setting()
pygame.init()
screen = pygame.display.set_mode(
[setting.screen_width, setting.screen_height])
pygame.display.set_caption("飞机大战")
ship = Ship(screen, setting)
bullets = Group()
aliens = Group()
gf.create_fleet(setting, screen, aliens)
stats = GameStats(setting)
sb = Scoreboard(setting, screen, stats)
play_button = Button(setting, screen, "Play")
while True:
gf.check_events(setting, screen, ship, bullets, stats, play_button,
aliens)
if stats.game_active:
ship.update()
gf.update_bullets(bullets, aliens, setting, screen, stats, sb)
gf.update_aliens(stats, setting, screen, aliens, ship, bullets)
gf.update_screen(setting, screen, ship, bullets, aliens, play_button,
stats, sb)
def reset():
Ent.next_id = 0
Ent.status = "idle"
Ent.current = ['empty']
Ent.cam_pos = [0, 0]
Ent.counter = -1
Ent.sdraw = False
Ent.fonts = tx.load_font()
Ent.sblue = (127, 118, 200)
Ent.nn = {'bunny': None, 'fox': None}
Ent.training = False
Ent.add = 0
Ent.database = {
'bunny': {
'inc': {
'hungry': 0.02, #002
'thirst': 0.025, #025
'love': 0.02, #002
'rest': 0.025 #0025
},
'base': {
'hungry': 100,
'thirst': 100,
'love': 100,
'rest': 100
},
'inf': {
'speed': 0,
'view': 6,
'maxchild': 8
}
},
'fox': {
'inc': {
'hungry': 0.03,
'thirst': 0.03,
'love': 0.02,
'rest': 0.03
},
'base': {
'hungry': 200,
'thirst': 200,
'love': 100,
'rest': 200
},
'inf': {
'view': 10,
'speed': 0,
'maxchild': 2
}
}
}
Ent.update = False
Ent.reg = list()
Ent.Sett = Setting(Ent.database)
#file= open("cmds.pkl", 'ab')
Action.update = Ent.update
Action.sdraw = Ent.sdraw
Action.database = Ent.database
def run_game():
#Initialize pygame, settings, and screen object.
pygame.init()
ai_settings = Setting()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
#Create an instance to store game statistics.
stats = GameStats(ai_settings)
#Make a Ship, a grooop of bullets and a group of aliens.
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
#create the fleet of aliens
gf.create_fleet(ai_settings, screen, ship, aliens)
#Set the Background Color.
#bg_color = (230, 230, 230)
#Make an alien
#alien = Alien(ai_settings, screen)
#Start the main loop for the game,
while True:
gf.check_events(ai_settings, screen, ship, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
def game():
pygame.init()
ai_setting = Setting()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
pygame.display.set_caption('Alien invasion')
play_button = Button(ai_setting, screen, "Play")
stats = GameStats(ai_setting)
sb = Scoreboard(ai_setting, screen, stats)
bg_color = (220, 220, 220)
alian = Alian(ai_setting, screen)
ship = Ship(screen, ai_setting)
bullets = Group()
alians = Group()
gf.create_fleet(ai_setting, screen, ship, alians)
while True:
gf.check_event(ai_setting, screen, stats, sb, play_button, ship,
alians, bullets)
gf.screen(ai_setting, screen, stats, sb, ship, bullets, alians,
play_button)
if stats.game_active:
ship.update()
gf.update_bullets(ai_setting, screen, stats, sb, ship, alians,
bullets)
gf.update_alians(ai_setting, screen, stats, sb, ship, alians,
bullets)
pygame.display.flip()
gf.screen(ai_setting, screen, stats, sb, ship, bullets, alians,
play_button)
def run_game():
# 初始化屏幕 创建一个屏幕对象
pygame.init()
ai_settings = Setting()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
play_button = Button(ai_settings, screen, "Play")
# 创建一艘 创建子弹 外星人
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# 创建外星人s
gf.create_fleet(ai_settings, screen, ship, aliens)
# 游戏的循环
while True:
# 事件
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, stats, sb, screen, ship, aliens,
bullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
def run_game():
#初始化一个游戏，并创建一个屏幕对象通过导入设置类Setting
pygame.init()
ai_setting = Setting()
game_stats = GameStats(ai_setting)
"""通过导入的设置模块初始化屏幕实例"""
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
pygame.display.set_caption("外星人")
ship = Ship(ai_setting, screen)
"""通过ship模块实例化飞船"""
bullets = pygame.sprite.Group()
"""实例化子弹集"""
aliens = pygame.sprite.Group()
"""实例化外星人集"""
stats = GameStats(ai_setting)
"""实例化游戏状态类"""
gf.create_fleet(ai_setting, screen, aliens, ship, game_stats)
while True:
"""游戏主循环，监控游戏的事件及刷新屏幕交给两个函数"""
if game_stats.ship_over == False:
gf.ship_ailen(ai_setting, screen, ship, aliens, bullets,
game_stats)
bullets.update(ai_setting, screen, ship, aliens, bullets)
for alien in aliens.sprites():
alien.update(game_stats)
gf.game_over(ai_setting, screen, ship, aliens, bullets, game_stats)
ship.update()
gf.check_event(ai_setting, screen, ship, bullets, aliens)
gf.update_screen(ai_setting, screen, ship, bullets, aliens, game_stats)
def run_game():
pygame.init()
ai_settings = Setting()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
ship = Ship(ai_settings, screen)
# 创建一个子弹编组
bullets = Group()
# 创建一个外星人组
aliens = Group()
# 创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
# 开始游戏循环
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_buttlets(bullets)
gf.update_aliens(ai_settings, aliens)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
pygame.display.flip()
def run_game():
pygame.init()
setting = Setting()
screen = pygame.display.set_mode(
(setting.screen_width, setting.screen_height))
pygame.display.set_caption("Alien Invaders")
ship = Ship(screen, setting)
bullets = Group()
aliens = Group()
play_button = Button(setting, screen, "Play")
stats = GameStats(setting)
sb = Scoreboard(setting, screen, stats)
g_o = GameOver(screen, "Game Over")
gf.create_fleet(setting, screen, aliens, ship)
while True:
gf.check_game(ship, setting, screen, bullets, aliens, stats,
play_button, sb)
gf.screen_update(setting, screen, ship, bullets, aliens, stats,
play_button, sb)
if stats.game_active:
ship.update()
gf.update_bullets(bullets, aliens, setting, ship, screen, stats,
sb)
gf.update_aliens(setting, aliens, ship, screen, bullets, stats, sb)
gf.screen_update(setting, screen, ship, bullets, aliens, stats,
play_button, sb)
def run_program():
pygame.init()
screen = pygame.display.set_mode((900, 650))
sr_setting = Setting()
pygame.display.set_caption("Sorting alogrithms")
fnt = pygame.font.SysFont("comicsans", 25)
fnt1 = pygame.font.SysFont("comicsans", 30)
array = [0] * 151
arr_color = [sr_setting.Green] * 151
clr = [
sr_setting.Green, sr_setting.Red, sr_setting.Dark_blue,
sr_setting.Orange, sr_setting.bg_color
]
pf.shuffel_arr(array)
while True:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
sys.exit()
if event.key == pygame.K_m:
ms.mergesort(array, 1,
len(array) - 1, arr_color, clr, screen, fnt,
fnt1)
if event.key == pygame.K_b:
bs.bubblesort(array, arr_color, clr, screen, fnt, fnt1)
if event.key == pygame.K_s:
qs.quicksort(array, arr_color, clr, screen, fnt, fnt1)
screen.fill(sr_setting.bg_color)
pf.draw(screen, fnt, fnt1, array, arr_color, clr)
pygame.display.flip()
def run_game():
#初始化游戏并创建一个屏幕对象
pygame.init()
screen = pygame.display.set_mode((1200, 800))
so_setting = Setting()
pygame.display.set_caption("Shot one")
#新建对象
bow = Bow(so_setting, screen)
arrow = Arrow(so_setting, screen, bow)
heart = Heart(so_setting, screen)
score = Scoreboard(so_setting, screen)
#游戏的主循环
while True:
gf.check_events(arrow, bow)
#更新三个对象
gf.update_bow(bow)
gf.update_arrow(arrow, heart, so_setting, score)
gf.update_heart(heart)
#更新屏幕
gf.update_screen(screen, so_setting, bow, arrow, heart, score)
#显示最新的屏幕
pygame.display.flip()
def run_game():
#初始化屏幕并且创建一个屏幕对象
pygame.init() #初始化
ai_settings = Setting()
screen = pygame.display.set_mode(
(ai_settings.screen_width,
ai_settings.screen_height)) #创建了一个屏幕对象screen设置屏幕大小
bg_color = (ai_settings.screen_color) #设置背景颜色
pygame.display.set_caption("Super_ship") #设置屏幕框显示的文字
ship = Ship(ai_settings, screen) #创建一艘飞船，不可以放在while循环中
ship_height = ship.rect.height
bullets = Group()
aliens = Group()
gf.creat_fleet(ai_settings, screen, aliens, ship_height)
stats = GameStates(ai_settings)
ship_limit = stats.ai_settings.ship_limit
#开始游戏的主循环
while True: #每经过一次循环就刷新一下屏幕
#监视键盘和鼠标事件
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_aliens(ai_settings, aliens, ship, bullets, stats, screen,
ship_height)
gf.update_bullets(ai_settings, screen, ship, bullets, aliens,
ship_height)
gf.update_screen(
ai_settings, screen, ship, bullets,
aliens) #每次循环都会重新绘制屏幕 #必须先进行填充背景色#将飞船放置在底端中间#让最近绘制的屏幕可见
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init()
ai_settings = Setting()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# 创建一艘飞船,一个子弹编组和一个外星人编组
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
# 创建外星人人群
gf.create_fleet(ai_settings, screen, ship, aliens)
# 开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
# 删除已消失的子弹
gf.update_bullets(aliens, bullets)
gf.update_aliens(ai_settings, aliens)
# 每次循环时都重绘屏幕
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
def run_game():
pygame.init()
setg = Setting()
#giving a tuple value for screen resolution
screen = pygame.display.set_mode((setg.scr_width, setg.scr_height))
pygame.display.set_caption('Alien Invasion')
stats = Stat(setg)
ship = Ship(screen, setg)
bullets = Group()
aliens = Group()
gf.new_fleet(screen, setg, aliens, ship)
play_button = Button(screen, 'START')
sb = Scoreboard(screen, setg, stats)
bg = BG(screen)
#game starts here
while True: #main loop of the game
gf.chk_events(sb, screen, ship, setg, bullets, stats, play_button,
aliens)
if stats.active_game:
ship.update()
gf.bullet_update(bullets, aliens, screen, setg, ship, stats, sb)
gf.alien_update(sb, aliens, setg, ship, stats, screen, bullets)
gf.scr_update(setg, screen, ship, aliens, bullets, stats, play_button,
sb, bg)
def setUp(self):
super(TestPostImpl, self).setUp()
setting = Setting()
setting.initialize(os.path.join(current_dir, 'settings.cfg'))
conn = Connection()
conn.connect(setting.config)
# initialize logger
Logger.init(**setting.config.twisted.logging)
Post.drop_collection()
# Redis 초기화
self.redis = conn.redis
self.redis.delete('current_post_id')
self.fake = Factory.create()
def run_game():
# calling pygame
pygame.init()
setting = Setting()
# putting the background
screen = pygame.display.set_mode([setting.width, setting.height])
background = pygame.transform.scale(pygame.image.load_basic('grass.bmp'),
(setting.width, setting.height))
backgroundrect = background.get_rect()
screen.blit(background, backgroundrect)
# loading the background music and setting a caption
rabbit = Bunny(screen, setting)
pygame.display.set_caption("Mouse Infestation")
pygame.mixer.music.load('moonlight.wav')
pygame.mixer.music.play(-1, 0.0)
pygame.mixer.music.set_volume(0.25)
# calling the classes
play_button = Button(setting, screen, "Play")
Health_bar = Health(screen)
stats = GameStats(setting)
sb = Scoreboard(setting, screen, stats)
bullets = Group()
mice = Group()
castles = Group()
gf.create_castle(screen, setting, 80, castles)
# making a loop for the game
while True:
# checking the program
gf.check_event(setting, screen, stats, play_button, sb, rabbit, mice,
bullets)
# placing the healthbar
if stats.game_active == False:
Health_bar.reset_health_bar()
# summoning the mice(enemies)
if stats.game_active:
for mouse in mice:
if mouse.rect.x < mouse.image.get_rect().centerx:
gf.create_fleet(setting, screen, mice)
break
# updating the screen in order for the program to run
rabbit.update()
gf.update_bullet(setting, screen, stats, sb, rabbit, bullets, mice)
gf.update_mouse(setting, Health_bar, screen, rabbit, mice, bullets,
castles, stats)
gf.update_screen(background, backgroundrect, screen, setting, sb,
rabbit, stats, bullets, mice, play_button, castles,
Health_bar)
def __init__(self):
pygame.init()
self.settings = Setting()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_hight))
pygame.display.set_caption("Alien Invision")
icon = pygame.image.load('Png.png')
pygame.display.set_icon(icon)
self.screen.fill(self.settings.bg_color)
self.ship = Ship(self)
def get(self):
nick = self.request.get('nick')
template_values = {
'title': 'Projects',
}
validuser = False
pd = ''
if nick is None or nick == '':
### Session verification code ###
session = get_current_session()
try:
validuser = True
user = User.get(session['key'])
template_values['logged'] = True
template_values['unread'] = UnreadMessages(session['key'])
except KeyError:
validuser = False
logging.error('-1')
projectdefaults = Setting.all().filter("name =", 'project_default').run()
pd = '/?exception=NoVariableNorSession'
for projectdefault in projectdefaults:
pd = projectdefault.value
logging.error(pd)
self.redirect(pd)
#################################
else:
validuser = False
for user in User.all().filter("nick =", nick).run(limit=1):
validuser = True
if validuser:
projects = Project.all().filter("user ="******"-date").run()
active = []
completed = []
dropped = []
for project in projects:
if project.status == 0:
active.append(project)
elif project.status == 1:
completed.append(project)
elif project.status == -1:
dropped.append(project)
template_values['projects'] = True
template_values['active'] = active
template_values['completed'] = completed
template_values['dropped'] = dropped
path = os.path.join(os.path.dirname(__file__), 'templates/projects.html')
self.response.out.write(template.render(path, template_values))
elif pd != '':
self.redirect(pd)
else:
self.redirect('/?exception=InvalidUser')
def run_game():
pygame.init()
ai_setting = Setting()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
pygame.display.set_caption('Alien')
ship = Ship(screen)
while True:
screen.fill(ai_setting.bg_color)
ship.blitme()
pygame.display.flip()
def __init__(self,ai_setting,screen): #类中的函数必须是要有self的
self.screen=screen
self.ai_settings=Setting()
self.images=pygame.image.load('images/small.bmp')
self.rect=self.images.get_rect()
self.screen_rect=screen.get_rect()
self.rect.bottom=self.screen_rect.bottom
self.rect.centerx=self.screen_rect.centerx
self.center=float(self.rect.centerx) ##因为rect的centerx只能存储整数所以需要在飞船的center属性中存储小数
self.move_left=False
self.move_right=False
def send(self, data: pd.DataFrame, attachments=[]):
emaillist = [elem.strip().split(',') for elem in self.receivers]
msg = MIMEMultipart()
msg['Subject'] = "Test Report"
msg['From'] = self.sender
### Email format ###
html = """\
<html>
<head></head>
<body>
{0}
</body>
</html>
""".format(data.to_html())
part1 = MIMEText(html, 'html')
msg.attach(part1)
### Attachment ###
if attachments:
for path in attachments:
filename = os.path.split(path)[-1]
with open(path, "rb") as attachment:
# Add file as application/octet-stream
# Email client can usually download this automatically as attachment
part = MIMEBase("application", "octet-stream")
part.set_payload(attachment.read())
# Encode file in ASCII characters to send by email
encoders.encode_base64(part)
# Add header as key/value pair to attachment part
part.add_header(
"Content-Disposition",
f"attachment; filename={filename}",
)
# Add attachment to message and convert message to string
msg.attach(part)
# Create a secure SSL context
context = ssl.create_default_context()
setting = Setting.get()
# Try to log in to server and send email
try:
server = smtplib.SMTP(self.smtp_server, self.tls_port)
server.ehlo() # Can be omitted
server.starttls(context=context) # Secure the connection
server.ehlo() # Can be omitted
server.login(self.sender, setting.sender_email_password)
# Send email here
server.sendmail(msg['From'], emaillist, msg.as_string())
logger.info(f"Successfully send email to {emaillist}.")
except Exception as e:
# Print any error messages to stdout
logger.error(str(e))
finally:
server.quit()
def run_game():
#初始化游戏并创建一个屏幕对象
pygame.init();
ai_setting = Setting();
screen = pygame.display.set_mode((ai_setting.screen_width,ai_setting.screen_height));
pygame.display.set_caption("alien_invasion");
#创建play按钮
play_button = Button(ai_setting,screen,"Play");
#创建一个用于存储游戏统计信息的实例
status = GameStatus(ai_setting);
#创建计分实例
sb = ScoreBoard(ai_setting,screen,status);
#创建一艘飞船
ship = Ship(ai_setting,screen);
#创建一个外星人
#alien = Alien(ai_setting,screen);
#创建一个用于存放子弹的组
bullets = Group();
#设置背景色
#bg_color = (230,230,230);
#创建一个用于存放外星人的组
aliens = Group();
#创建外星人群
gf.create_fleet(ai_setting,screen,ship,aliens);
#开始游戏主循环
while True:
#监视键盘和鼠标事件
gf.check_events(ai_setting,screen,status,sb,play_button,ship,aliens,bullets);
#还有飞船的时候更新
if status.game_active:
#更新飞船位置
ship.update();
#更新外星人位置
gf.update_aliens(ai_setting,status,sb,screen,ship,aliens,bullets);
#更新子弹信息
gf.update_bullets(ai_setting,screen,status,sb,ship,aliens,bullets);
#刷新屏幕
gf.update_screen(ai_setting,screen,status,sb,ship,aliens,bullets,play_button);
def evaluate(assetId: str,
strategyId: str,
df: pd.DataFrame,
evaluationPeriod: EvaluationPeriod = None,
deleteTemp=False) -> bool:
"""
Evaluate the performance of an arbitrary strategy. Columns required in df for evaluation process as below
:param
assetId:
strategyId: ID of the strategy with the specific set of parameters that generate 'position' for data
df: assume the existence of these columns after running through a Strategy
position: determine the position of the asset at each point in time
:return: the enriched df with evaluation parameters if pass evaluation criteria, else return None
"""
name = '_'.join([assetId, strategyId, evaluationPeriod.name])
### evaluation parameters
df['asset_ret'] = df['Adj Close'].pct_change()
df['return'] = df['asset_ret'] * df['position']
df['unit_asset_ret'] = (1 + df['asset_ret']).cumprod()
df['value'] = (1 + df['return']).cumprod()
### evaluate
if not deleteTemp:
tempDir = None
tempPath = get_temp_path()
if not os.path.exists(tempPath):
os.makedirs(tempPath)
else:
tempDir = tempfile.TemporaryDirectory()
tempPath = tempDir.name
graph_file_extension = Setting.get().graph_file_extension
tempPath = os.path.join(tempPath, name)
fig = plt.figure(figsize=(15, 10))
s1 = fig.add_subplot(2, 1, 1)
s1.plot(df['value'], label='Portfolio unit value')
s1.plot(df['unit_asset_ret'], label='Asset unit value')
s1.legend()
s1.set_title("Return")
s2 = fig.add_subplot(2, 1, 2)
alpha = df['value'] - df['unit_asset_ret']
s2.plot(alpha, label='Excess return compared to asset', color='r')
s2.legend()
s2.set_title("Alpha")
fig.savefig(tempPath + f'.{graph_file_extension}',
format=graph_file_extension)
plt.close(fig)
logger.info(f"Graph for {name} generated at {tempPath}.")
if tempDir: tempDir.cleanup()
### TODO: define the criteria for a pass
if not True:
return None
return df
def get(self):
nick = self.request.get('nick')
validuser = False
pins = None
template_values = {
'pagename': 'wall',
}
if nick is not None and nick != '':
userQ = User.all().filter("nick =", nick).run(limit=1)
for user in userQ:
validuser = True
pins = Pin.all().filter("user ="******"-date").run(limit=50)
try:
session = get_current_session()
if session['key'] and session['key'] != '':
unread = UnreadMessages(session['key'])
template_values['logged'] = True
template_values['unread'] = unread
validuser = True
if pins is None:
pins = Pin.all().filter("user ="******"-date").run(limit=50)
except KeyError:
logging.error('Key error getting session. No session opened. PASS.')
if validuser:
template_values['pins'] = pins
path = os.path.join(os.path.dirname(__file__), 'templates/wall.html')
self.response.out.write(template.render(path, template_values))
else:
#logging.error('User ' + nick + ' not found. EXIT.')
#self.redirect('/?exception=NickNotFound')
walldefaults = Setting.all().filter("name =", 'wall_default').run()
wd = '/?exception=NoVariableNorSession'
for walldefault in walldefaults:
wd = walldefault.value
self.redirect(wd)
def __init__(self):
self.regstatus = False
regstatusesQ = Setting.all().filter("name =", 'register').filter("value =", 'enabled').run()
for regstatuses in regstatusesQ:
self.regstatus = True
def get(self):
nick = self.request.get('nick')
page = self.request.get('page')
template_values = {
'title': 'Blog',
}
validuser = False
# If a nick value is not given, assuming a user is logged, using his key to get entries
bd = ''
if nick is None or nick == '':
### Session verification code ###
session = get_current_session()
try:
logging.error('1')
validuser = True
user = User.get(session['key'])
template_values['logged'] = True
template_values['unread'] = UnreadMessages(session['key'])
except KeyError:
validuser = False
logging.error('-1')
blogdefaults = Setting.all().filter("name =", 'blog_default').run()
bd = '/?exception=NoVariableNorSession'
for blogdefault in blogdefaults:
bd = blogdefault.value
logging.error(bd)
self.redirect(bd)
#################################
# If a nick is specified in a variable, get the user's entries
else:
logging.error('2')
validuser = False
for user in User.all().filter("nick =", nick).run(limit=1):
validuser = True
if validuser:
ref = self.request.get('ref')
batchsize = self.request.get('batchsize')
if ref is not None and ref != '':
pagesref = Entry.all().filter("user ="******"-date").run()
countentry = 0
for pageref in pagesref:
if pageref.key().id() != int(ref):
countentry += 1
else:
break
if batchsize is None or batchsize == '':
batchsize = 5
else:
batchsize = int(batchsize)
entdiv = countentry / batchsize
floatdiv = countentry % batchsize
logging.warning(str(countentry) + " - " + str(entdiv) + " - " + str(floatdiv))
if floatdiv > 0:
entdiv += 1
self.redirect("/blog?page=" + str(entdiv) + "#" + ref)
# Try to get page number and batch size from given parameters to determine which entries to show. Default [0:5]
if page is None or page == '' or page == '0':
page = 1
else:
page = int(page)
if batchsize is None or batchsize == '':
batchsize = 5
else:
batchsize = int(batchsize)
offset = (int(page) - 1) * batchsize
# Get entries and for each one, get the corresponding pictures, build a dictionary with attributes both from Entry and EntryBlob, and add it to a list of entries
entries = Entry.all().filter("user ="******"-date").run(offset=offset,limit=batchsize)
entrieslist = []
for entry in entries:
entrydict = {'id': str(entry.key().id()), 'key': str(entry.key()), 'title': entry.title, 'body': entry.body, 'shortdesc': entry.body[0:297] + '...', 'date': str(entry.date).split('.')[0], 'author': user.nick}
blobslist = []
entryblob = EntryBlob.all().filter("entry =", str(entry.key())).run()
for blob in entryblob:
blobslist.append({'key': str(blob.key()), 'blob': blob.blob, 'position': blob.position})
entrydict['blobs'] = blobslist
sharedpics = EntryBlob.all().filter("entry =", str(entry.key())).run(limit=1)
for pic in sharedpics:
sharedpic = {'key': str(pic.key()), 'blob': pic.blob}
entrydict['sharedpic'] = sharedpic
tags = ""
taggedQ = Tagged.all().filter("entitykey =", str(entry.key())).run()
for tagged in taggedQ:
tag = Tag.get(tagged.tagkey)
if tags == "":
tags += tag.tag
else:
tags += ", " + tag.tag
if len(tags) > 0:
entrydict['tags'] = tags
logging.info('Tags: ' + tags)
entrieslist.append(entrydict)
template_values['entries'] = entrieslist
path = os.path.join(os.path.dirname(__file__), 'templates/blog.html')
self.response.out.write(template.render(path, template_values))
elif bd != '':
self.redirect(bd)
else:
self.redirect('/?exception=InvalidUser')
def get(self):
puser = self.request.get('user')
action = self.request.get('action')
self.response.headers['Content-Type'] = 'application/json'
if puser is not None and puser != '':
try:
user = User.get(puser)
if action == 'gamelist':
bogeyslist = []
gameslist = []
playerslist = []
gamesdetails = []
returndict = {'user': {'nick': user.nick, 'avatar': user.avatar, 'fname': user.fname, 'lname': user.lname}}
bogeys = Monster.all().filter("user ="******"monster IN", bogeyslist).run()
for player in players:
playerslist.append(player.key())
gameslist.append(player.game)
for game in gameslist:
ggame = Game.get(game)
gamedict = {'name': ggame.name, 'owner': ggame.owner, 'status': ggame.status, 'date': ggame.date}
playerslist = []
gplayers = Player.all().filter("game =", game).run()
for gplayer in gplayers:
gmonster = Monster.get(gplayer.monster)
guser = User.get(gmonster.user)
playerdict = {'nick': user.nick, 'avatar': user.avatar, 'fname': user.fname, 'lname': user.lname, 'monster': {'name': gmonster.name, 'date': gmonster.date}}
playerslist.append(playerdict)
gamedict['players'] = playerslist
gameslist.append(gamedict)
returndict['games'] = gameslist
self.response.out.write(json.dumps(returndict))
elif action == 'newmonster':
monsterlimit = 3
smonsterlimits = Setting.all().filter("name =", 'monster_limit').run(limit=1)
for smonsterlimit in smonsterlimits:
monsterlimit = smonsterlimit.value
monsterlist = []
gmonsters = Monster.all().filter("user ="******"user ="******"name =", 'game_limit').run(limit=1)
for sgamelimit in sgamelimits:
gamelimit = sgamelimit.value
gamelist = []
monsterlist = []
gmonsters = Monster.all().filter("user ="******"monster in", monsterlist).run()
for gplayer in gplayers:
game = Game.get(gplayer.game)
gamedict = game.name
gamelist.append(gamedict)
if len(gamelist) < gamelimit:
pname = self.request.get('name')
if pname is not None and pname != '':
if pname not in gamelist:
size = self.request.get('size').split('x')
if len(size) == 2:
pmonster = self.request.get('monster')
if pmonster is not None and pmonster != '':
monster = Monster.get(pmonster)
if monster.user == puser:
newgame = Game()
newgame.name = pname
newgame.owner = puser
newgame.status = 0
newgame.put()
board = Board()
board.game = str(newgame.key())
#size = int(size)
sizeblob = []
for val in size:
val = int(val)
sizeblob.append(val)
board.size = json.dumps(sizeblob)
board.put()
newplayer = Player()
newplayer.game = str(newgame.key())
newplayer.monster = pmonster
newplayer.position = json.dumps([randnum(sizeblob[0]), randnum(sizeblob[1])])
logging.info('position: ' + str(json.loads(newplayer.position)))
newplayer.put()
self.response.out.write(json.dumps({'status': 1, 'message': 'Game ' + pname + ' successfully created.'}))
else:
self.response.out.write(json.dumps({'status': -9, 'message': 'Invalid combo monster/user.'}))
else:
self.response.out.write(json.dumps({'status': -8, 'message': 'Missing parameter monster.'}))
else:
self.response.out.write(json.dumps({'status': -7, 'message': 'Wrong size value, not in range'}))
else:
self.response.out.write(json.dumps({'status': -6, 'message': 'The user already is in a game called ' + pname + '.'}))
else:
self.response.out.write(json.dumps({'status': -4, 'message': 'Missing parameter for game creation'}))
else:
self.response.out.write(json.dumps({'status': -5, 'message': 'Game limit of ' + str(gamelimit) + ' reached for user'}))
elif action == 'joingame':
ggame = self.request.get('game')
gmonster = self.request.get('monster')
if ggame is None or ggame == '' or gmonster is None or gmonster == '':
self.response.out.write(json.dumps({'status': -10, 'message': 'Missing mandatory parameter(s).'}))
else:
game = Game.get(ggame)
monster = Monster.get(gmonster)
if monster.user == puser:
monsterlist = []
playermonsters = Monster.all().filter("user ="******"monster in", monsterlist).run():
gamelist.append(playergame.game)
if ggame not in gamelist:
ingame = False
gplayers = Player.all().filter("monster =", gmonster).run(limit=1)
for gplayer in gplayers:
ingame = True
if not ingame:
gamelimit = 4
if game.slots != None:
gamelimit = game.slots
gameplayerlist = []
gameplayers = Player.all().filter("game =", ggame).run(limit=gamelimit)
for gameplayer in gameplayers:
gameplayerlist.append(gameplayer.monster)
if len(gameplayerlist) < gamelimit:
player = Player()
player.game = ggame
player.put()
self.response.out.write(json.dumps({'status': 1, 'message': 'Successfully joined game ' + game.name + '.'}))
else:
self.response.out.write(json.dumps({'status': -12, 'message': 'No open slots left for game ' + ggame + '.'}))
else:
self.response.out.write(json.dumps({'status': -13, 'message': 'Player already in game ' + ggame + '.'}))
else:
self.response.out.write(json.dumps({'status': -11, 'message': 'Monster already in a game.'}))
else:
self.response.out.write(json.dumps({'status': -9, 'message': 'Invalid combo monster/user.'}))
elif action == 'modifygame':
#Modify/delete game if the owner is requesting and if it has no player but the owner
logging.info('action: ' + action)
method = self.request.get('method')
if method == 'm':
logging.info('method: ' + method)
elif method == 'd':
logging.info('method: ' + method)
else:
self.response.out.write(json.dumps({'status': -14, 'message': 'Invalid method "' + method + '" for action ' + action + '.'}))
elif action == 'modifymonster':
#Modify/delete a monster if the owner is requesting it and if the monster is not in a started game
logging.info('action: ' + action)
method = self.request.get('method')
if method == 'm':
logging.info('method: ' + method)
elif method == 'd':
logging.info('method: ' + method)
else:
self.response.out.write(json.dumps({'status': -14, 'message': 'Invalid method "' + method + '" for action ' + action + '.'}))
else:
self.response.out.write(json.dumps({'status': -3, 'message': 'Invalid action parameter'}))
except db.BadKeyError:
self.response.out.write(json.dumps({'status': -2, 'message': 'Invalid key'}))
else:
self.response.out.write(json.dumps({'status': -1, 'message': 'Wrong user parameter'}))
from agent import Agent
import fife
from settings import Setting
TDS = Setting()
_STATE_NONE, _STATE_IDLE, _STATE_RUN, _STATE_FOLLOW = 0, 1, 2, 3
GIRL_SPEED = 3 * float(TDS.readSetting("TestAgentSpeed"))
class Girl(Agent):
def __init__(self, model, agentName, layer, uniqInMap=True):
super(Girl, self).__init__(model, agentName, layer, uniqInMap)
self.state = _STATE_NONE
self.waypoints = ((67, 80), (75, 44))
self.waypoint_counter = 0
self.hero = self.layer.getInstance('PC')
def onInstanceActionFinished(self, instance, action):
if self.state in (_STATE_RUN, _STATE_FOLLOW):
self.idle()
else:
if self.waypoint_counter % 3:
self.waypoint_counter += 1
self.follow_hero()
else:
self.run(self.getNextWaypoint())
def getNextWaypoint(self):
self.waypoint_counter += 1
l = fife.Location(self.layer)
l.setLayerCoordinates(fife.ModelCoordinate(*self.waypoints[self.waypoint_counter % len(self.waypoints)]))
def __getattr__(self, item):
Logger.info(item)
item = re.split('_', item)
module_name, mthd = item[0], '_'.join(item[1:])
class_name = module_name.capitalize() + 'Controller'
module = __import__('controllers.%s' % module_name)
instance = getattr(getattr(module, module_name), class_name)()
return getattr(instance, mthd)
if __name__ == '__main__':
setting = Setting()
setting.initialize(os.path.join(current_dir, 'settings.cfg'))
conn = Connection()
conn.connect(setting.config)
# initialize logger
Logger.init(**setting.config.twisted.logging)
# setup server
handler = TodayInternalApiServiceHandler()
processor = TodayInternalApiService.Processor(handler)
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = reactor.listenTCP(setting.config.twisted.port,
TTwisted.ThriftServerFactory(processor, pfactory),
interface=setting.config.twisted.interface)
if p not in sys.path:
sys.path.append(_jp(p))
if not os.path.exists('settings.xml'):
shutil.copyfile('settings-dist.xml', 'settings.xml')
import fife_compat
import fife, fifelog
from scripts import world
from scripts.common import eventlistenerbase
from basicapplication import ApplicationBase
import pychan
import pychan.widgets as widgets
from settings import Setting
TDS = Setting()
class ApplicationListener(eventlistenerbase.EventListenerBase):
def __init__(self, engine, world):
super(ApplicationListener, self).__init__(engine,regKeys=True,regCmd=True, regMouse=False, regConsole=True, regWidget=True)
self.engine = engine
self.world = world
engine.getEventManager().setNonConsumableKeys([
fife.Key.ESCAPE,])
self.quit = False
self.aboutWindow = None
self.rootpanel = pychan.loadXML('gui/rootpanel.xml')
self.rootpanel.mapEvents({
'quitButton' : self.onQuitButtonPress,
