def temporal_join(u, v, v_name, key, time_col): timer = Timer() window_size = CONSTANT.WINDOW_SIZE if len(u) * CONSTANT.WINDOW_RATIO < CONSTANT.WINDOW_SIZE \ else int(len(u) * CONSTANT.WINDOW_RATIO) hash_max = CONSTANT.HASH_MAX if len(u) / CONSTANT.HASH_MAX > CONSTANT.HASH_BIN \ else int(len(u) / CONSTANT.HASH_BIN) # window_size = CONSTANT.WINDOW_SIZE # hash_max = CONSTANT.HASH_MAX if isinstance(key, list): assert len(key) == 1 key = key[0] tmp_u = u[[time_col, key]] timer.check("select") tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) timer.check("concat") # rehash_key = f'rehash_{key}' # tmp_u[rehash_key] = tmp_u[key].apply(lambda x: hash(x) % hash_max) # timer.check("rehash_key") tmp_u.sort_values(time_col, inplace=True) timer.check("sort") agg_funcs = { col: Config.aggregate_op(col) for col in v if col != key and not col.startswith(CONSTANT.TIME_PREFIX) and not col.startswith(CONSTANT.MULTI_CAT_PREFIX) } # tmp_u = tmp_u.groupby(rehash_key).rolling(window=5).agg(agg_funcs) tmp_u = tmp_u.rolling(window=window_size).agg(agg_funcs) timer.check("group & rolling & agg") # tmp_u.reset_index(0, drop=True, inplace=True) # drop rehash index # timer.check("reset_index") tmp_u.columns = tmp_u.columns.map( lambda a: f"{CONSTANT.NUMERICAL_PREFIX}{a[1].upper()}_ROLLING5({v_name}.{a[0]})") if tmp_u.empty: log("empty tmp_u, return u") return u ret = pd.concat([u, tmp_u.loc['u']], axis=1, sort=False) timer.check("final concat") del tmp_u return ret
class JumpTimer(object): '''When hitting the ground wait a bit before jumping again. When leaving the ground wait a bit before forbidding jumps''' def __init__(self): object.__init__(self) self.timer = None self.wait_timer = None def set(self): # Add a 100ms timer self.timer = Timer(config.getint('Physics','jump_time')) def update(self, ms): # Remove timer when time runs out if self.timer and self.timer.check(ms): self.unset() def jump_allowed(self): return self.timer is not None def unset(self): self.timer = None
except KeyError: Glof = None # Load the missense burdens try: Gmiss = bloader_missense.genotypes_by_id(gene).astype(float) except KeyError: Gmiss = None call(Glof, 'pLOF') call(Gmiss, 'missense') if (Glof is None) or (Gmiss is None): call(None, 'mrg') else: G = np.maximum(Glof, Gmiss) call(G, 'mrg') return pval_dict timer = Timer() results = pd.DataFrame.from_dict([test_gene(gene) for gene in genes]).set_index('gene') t = timer.check() logging.info('{} genes tested in {:.2f} minutes.'.format( len(results), t / 60.)) results.to_csv(snakemake.output.results_tsv, sep='\t', index=True, na_rep='.')
def temporal_join(u, v, v_name, key, time_col): timer = Timer() if isinstance(key, list): key = key[0] tmp_u = u[[time_col, key]] timer.check("select") tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) timer.check("concat") rehash_key = f'rehash_{key}' tmp_u[rehash_key] = tmp_u[key].apply(lambda x: hash(x) % CONSTANT.HASH_MAX) timer.check("rehash_key") tmp_u.sort_values(time_col, inplace=True) timer.check("sort") agg_funcs = { col: Config.aggregate_op(col) for col in v if col != key and not col.startswith(CONSTANT.TIME_PREFIX) and not col.startswith(CONSTANT.MULTI_CAT_PREFIX) } tmp_u = tmp_u.groupby(rehash_key).rolling(5).agg(agg_funcs) timer.check("group & rolling & agg") tmp_u.reset_index(0, drop=True, inplace=True) # drop rehash index timer.check("reset_index") def rename_func(x): dtype = CONSTANT.CATEGORY_PREFIX if x[1].upper() in [ 'MODE' ] else CONSTANT.NUMERICAL_PREFIX return f"{dtype}{x[1].upper()}_ROLLING10({v_name}.{x[0]})" tmp_u.columns = tmp_u.columns.map(rename_func) if tmp_u.empty: log("empty tmp_u, return u") return u ret = pd.concat([u, tmp_u.loc['u']], axis=1, sort=False) timer.check("final concat") del tmp_u return ret
G1 = np.concatenate([G1, G2], axis=1) call_score(G1, 'linwcollapsed_cLOF') call_lrt(G1, 'linwcollapsed_cLOF') pval_dict['nCarrier'] = ncarrier pval_dict['cumMAC'] = cummac.sum() pval_dict['n_homo'] = n_homo pval_dict['n_snp'] = len(vids) pval_dict['n_cluster'] = len(set(clusters)) # sanity check assert pval_dict['cumMAC'] >= pval_dict['nCarrier'], 'Error: something is broken.' return pval_dict, sim_dict logging.info('loaders for chromosome {} initialized in {:.1f} seconds.'.format(chromosome, timer.check())) # run tests for all genes on the chromosome for _, region in regions.iterrows(): try: gene_stats, sims = test_gene(region, i_gene) except GotNone: continue stats.append(gene_stats) simulations.append(sims) i_gene += 1 if (i_gene % 100) == 0: logging.info('tested {} genes...'.format(i_gene)) logging.info('all tests for chromosome {} performed in {:.2f} minutes.'.format(chromosome, timer.check()/60.))
call_score(G2, 'LOF') call_lrt(G2, 'LOF') # merged (single variable) G1_burden_mrg = np.maximum(G2, G1_burden) call_score(G1_burden_mrg, 'linwb_mrgLOF') call_lrt(G1_burden_mrg, 'linwb_mrgLOF') # concatenated call_score(np.concatenate([G1, G2], axis=1), 'linwcollapsed_cLOF') call_lrt(np.concatenate([G1, G2], axis=1), 'linwcollapsed_cLOF') pval_dict['linwcollapsed_cLOF']['cluster_id'] = sorted(set(clusters)) + [-1] # -1 indicates the LOF cluster return pval_dict, called logging.info('loaders for chromosome {} initialized in {:.1f} seconds.'.format(chromosome, timer.check())) # run tests for all genes on the chromosome for _, region in regions.iterrows(): try: gene_stats, called = test_gene(region, i_gene) except GotNone: continue # build the single-variant datafame single_var_columns = ['gene','vid','weights','MAC','nCarrier','pos','ref','alt','cosine_similarity','cluster_id'] sv_df = pd.DataFrame.from_dict({k: gene_stats[k] for k in single_var_columns}) sv_df['pv_score'] = gene_stats['variant_pvals']['pv_score'] # single-variant p-values estimated independently sv_df['coef_random'] = gene_stats['variant_pvals']['coef_random'] # single-variant coefficients estimated jointly after weighting
G1 = np.concatenate([G1[:, keep], G2], axis=1) call_score(G1, 'linw_cLOF', vids=np.array(vids[keep].tolist() + [-1])) call_lrt(G1, 'linw_cLOF') else: logging.info( 'All Splice-AI variants for gene {} where already identified by the Ensembl variant effect predictor' .format(interval['name'])) return pval_dict, called logging.info( 'loaders for chromosome {} initialized in {:.1f} seconds.'.format( chromosome, timer.check())) # run tests for all genes on the chromosome for _, region in regions.iterrows(): try: gene_stats, called = test_gene(region, i_gene) except GotNone: continue # build the single-variant datafame single_var_columns = [ 'gene', 'vid', 'weights', 'MAC', 'nCarrier', 'not_LOF', 'DS_AG', 'DS_AL', 'DS_DG', 'DS_DL', 'DP_AG', 'DP_AL', 'DP_DG', 'DP_DL' ] sv_df = pd.DataFrame.from_dict( {k: gene_stats[k]
pval_dict['n_snp_notLOF'] = keep.sum() pval_dict['cumMAC_notLOF'] = cummac[keep].sum() pval_dict['nCarrier_notLOF'] = ncarrier_notLOF pval_dict['flag1'] = flag1 pval_dict['flag2'] = flag2 # sanity check assert pval_dict['cumMAC'] >= pval_dict[ 'nCarrier'], 'Error: something is broken.' return pval_dict, sim_dict logging.info( 'loaders for chromosome {}, strand "{}" initialized in {:.1f} seconds.' .format(chromosome, strand, timer.check())) # run tests for all genes on the chromosome / strand for _, region in regions.iterrows(): try: gene_stats, sims = test_gene(region, i_gene) except GotNone: continue stats.append(gene_stats) simulations.append(sims) i_gene += 1 if (i_gene % 100) == 0: logging.info('tested {} genes...'.format(i_gene)) # print(i_gene)
def temporal_join(u, v, v_name, key, time_col): timer = Timer() if isinstance(key, list): assert len(key) == 1 key = key[0] print ("-----tmp_u--------") tmp_u = u[[time_col, key]] print ("------Number of columns before concatenation---") print (len(tmp_u.columns)) timer.check("select") tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) print (len(tmp_u.columns)) timer.check("concat") rehash_key = f'rehash_{key}' tmp_u[rehash_key] = tmp_u[key].apply(lambda x: hash(x) % CONSTANT.HASH_MAX) timer.check("rehash_key") tmp_u.sort_values(time_col, inplace=True) print ("----after sorting----") #print (tmp_u) print ("----after sorting----") timer.check("sort") agg_funcs = {col: Config.aggregate_op(col) for col in v if col != key and not col.startswith(CONSTANT.TIME_PREFIX) and not col.startswith(CONSTANT.MULTI_CAT_PREFIX)} print ("-----after group by operation-----") tmp_u = tmp_u.groupby(rehash_key).rolling(5, min_periods=1).agg(agg_funcs) #print (tmp_u) print ("-----after group by operation------") print ("-----tmp_u--------") timer.check("group & rolling & agg") tmp_u.reset_index(0, drop=True, inplace=True) # drop rehash index timer.check("reset_index") tmp_u.columns = tmp_u.columns.map(lambda a: f"{CONSTANT.NUMERICAL_PREFIX}{a[1].upper()}_ROLLING5({v_name}.{a[0]})") if tmp_u.empty: log("empty tmp_u, return u") return u #print ("----number of rows in u-----") #print (len(u.index)) #print ("---number of rows in u-----") #print ("----number of rows in tmp_u-----") #print (len(tmp_u.index)) #print ("----number of rows in tmp_u---------") ret = pd.concat([u, tmp_u.loc['u']], axis=1, sort=False) timer.check("final concat") del tmp_u return ret
pval_dict['nCarrier_notLOF'] = ncarrier_notLOF pval_dict['cumMAC_notLOF'] = cummac[keep].sum() # 0.5 is the recommended spliceAI cutoff pval_dict['n_greater_05'] = np.sum(weights >= 0.5) pval_dict['n_greater_05_notLOF'] = np.sum(weights[keep] >= 0.5) # sanity check assert pval_dict['cumMAC'] >= pval_dict[ 'nCarrier'], 'Error: something is broken.' return pval_dict, sim_dict logging.info( 'loaders for chromosome {} initialized in {:.1f} seconds.'.format( chromosome, timer.check())) # run tests for all genes on the chromosome for _, region in regions.iterrows(): try: gene_stats, sims = test_gene(region, i_gene) except GotNone: continue stats.append(gene_stats) simulations.append(sims) i_gene += 1 if (i_gene % 100) == 0: logging.info('tested {} genes...'.format(i_gene)) # print(i_gene)
def temporal_join(u, v, v_name, key, time_col, type_): if type_.split("_")[2] == 'many': timer = Timer() if isinstance(key, list): assert len(key) == 1 key = key[0] tmp_u = u[[time_col, key]] timer.check("select") # print(tmp_u) tmp_u = pd.concat([v, tmp_u], keys=['v', 'u'], sort=False) # tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) timer.check("concat") # print(tmp_u) rehash_key = f'rehash_{key}' hash_max_tmp = tmp_u[key].nunique() if hash_max_tmp > 3000: tmp = min(int(hash_max_tmp / 10), 3000) hash_max = tmp - tmp % 100 else: hash_max = hash_max_tmp - hash_max_tmp % 100 # hash_max = hash_max_tmp % 10000 print("#" * 20) print(hash_max) print("#" * 20) tmp_u[rehash_key] = tmp_u[key].apply(lambda x: hash(x) % hash_max) # tmp_u[rehash_key] = tmp_u[key].apply(lambda x: hash(x) % CONSTANT.HASH_MAX) timer.check("rehash_key") # print(tmp_u) tmp_u.sort_values(time_col, inplace=True) timer.check("sort") # print(tmp_u) tmp_u = tmp_u.groupby(rehash_key).fillna(method='ffill') timer.check("group & ffill") # print(tmp_u) tmp_u = tmp_u.loc['u'] # print(tmp_u) tmp_u.sort_index(inplace=True) # print(tmp_u) needed_cols = [ col for col in tmp_u if col != key and col != rehash_key and col != time_col ] tmp_u = tmp_u[needed_cols] tmp_u.columns = tmp_u.columns.map( lambda a: f"{a.split('_', 1)[0]}_{v_name}_TMJOIN.{a}") timer.check("get tmp_u to cnocat") # print(tmp_u) if tmp_u.empty: log("empty tmp_u, return u") return u ret = pd.concat([u, tmp_u], axis=1, sort=False) timer.check("final concat") del tmp_u else: v = v.set_index(key) v.columns = v.columns.map( lambda a: f"{a.split('_', 1)[0]}_{v_name}_TOJOIN.{a}") ret = u.join(v, on=key) return ret
def temporal_join(u, v, v_name, key, time_col): timer = Timer() if isinstance(key, list): assert len(key) == 1 key = key[0] tmp_u = u[[time_col, key]] timer.check("select") #tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) #timer.check("concat") tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) timer.check("concat") rehash_key = f'rehash_{key}' tmp_u[rehash_key] = tmp_u[key].apply(lambda x: hash(x) % CONSTANT.HASH_MAX) timer.check("rehash_key") tmp_u.sort_values(time_col, inplace=True) timer.check("sort") agg_funcs = { col: Config.aggregate_op(col) for col in v if col != key and not col.startswith(CONSTANT.TIME_PREFIX) and not col. startswith(CONSTANT.MULTI_CAT_PREFIX) and 'mul_feature_' not in col } tmp_u_2 = tmp_u ##---------------FillNA----------------- #tmp_u = tmp_u.groupby(rehash_key).rolling(5).agg(agg_funcs) # tmp_u_2 = tmp_u tmp_u = tmp_u.groupby(key).agg(agg_funcs) timer.check("group & rolling & agg") # tmp_u.reset_index(0, drop=True, inplace=True) # drop rehash index timer.check("reset_index") # tmp_u.columns = tmp_u.columns.map(lambda a: # f"{CONSTANT.NUMERICAL_PREFIX}{a[1].upper()}_ROLLING5({v_name}.{a[0]})") if tmp_u.empty: log("empty tmp_u, return u") return u # print(u.shape,tmp_u.loc['u'].shape,tmp_u_2.shape) # ret = pd.concat([u, tmp_u_2], axis=1, sort=False) # ret = pd.concat([u, tmp_u.loc['u'],tmp_u_2], axis=1, sort=False) # ret = pd.concat([u, tmp_u.loc['u']], axis=1, sort=False) timer.check("final concat") tmp_u.columns = tmp_u.columns.map(lambda a: f"{v_name}.{a})") tmpindex = u.index u["index"] = list(range(0, len(tmpindex))) ret = pd.merge(u, tmp_u, left_index=True, on=[key]) ret.sort_values("index", inplace=True) # ret.index = ret["index"] ret.index = tmpindex ret.drop("index", axis=1, inplace=True) # u[key] = u[key].apply(int) # v[key] = v[key].apply(int) # #u = u.join(v,on=key) # u = u.merge(v) # print(u) del tmp_u return u
def temporal_join_jinnian(u, v, v_name, key, time_col, type_): if isinstance(key, list): assert len(key) == 1 key = key[0] if type_.split("_")[2] == 'many': timer = Timer() tmp_u = u[[time_col, key]] timer.check("select") # tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) # timer.check("concat") # tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) for c in v.columns: if c != key and c.startswith(CONSTANT.CATEGORY_PREFIX): v[c] = v[c].apply(lambda x: int(x)) tmp_u = pd.concat([tmp_u, v], sort=False) #tmp_u = v # print(tmp_u.index) # input() # print(tmp_u[key].nunique()) # input() timer.check("concat") rehash_key = f'rehash_{key}' # tmp_u[rehash_key] = tmp_u[key].apply(lambda x: hash(x) % CONSTANT.HASH_MAX) timer.check("rehash_key") # tmp_u.sort_values(time_col, inplace=True) timer.check("sort") agg_funcs = { col: Config.aggregate_op(col) for col in v if col != key and not col.startswith(CONSTANT.TIME_PREFIX) and not col.startswith(CONSTANT.MULTI_CAT_PREFIX) and 'mul_feature_' not in col } tmp_u = tmp_u.fillna(0).groupby(key).agg(agg_funcs) '''agg_funcs_num = {col: Config.aggregate_op(col) for col in v if col != key and col.startswith(CONSTANT.NUMERICAL_PREFIX) } agg_funcs_cat = {col: Config.aggregate_op(col) for col in v if col != key and col.startswith(CONSTANT.CATEGORY_PREFIX) } num_features = [c for c in tmp_u.columns if c.startswith(CONSTANT.NUMERICAL_PREFIX)] if key not in num_features: num_features.append(key) cat_features = [c for c in tmp_u.columns if c.startswith(CONSTANT.CATEGORY_PREFIX)] if key not in cat_features: cat_features.append(key) #print(num_features) #print(cat_features) #input() tmp_u_num = tmp_u[num_features] tmp_u_cat = tmp_u[cat_features]''' ##---------------FillNA----------------- # tmp_u = tmp_u.groupby(rehash_key).rolling(5).agg(agg_funcs) ##tmp_u = tmp_u.fillna(0).groupby(rehash_key).rolling(5).agg(agg_funcs) '''if len(num_features) > 1: tmp_u_cat = tmp_u_cat.groupby(key).agg(agg_funcs_cat) tmp_u_cat.reset_index(0, inplace=True) if len() tmp_u_num = tmp_u_num.fillna(0).groupby(key).agg(agg_funcs_num) tmp_u_num.reset_index(0, inplace=True) print(tmp_u_cat.index) print(tmp_u_cat.columns) print(tmp_u_num.index) print(tmp_u_num.columns) input() tmp_u = pd.merge(tmp_u_cat, tmp_u_num, on=[key])''' timer.check("group & rolling & agg") # tmp_u.reset_index(0, drop=True, inplace=True) # drop rehash index timer.check("reset_index") tmp_u.columns = tmp_u.columns.map( lambda a: f"{CONSTANT.NUMERICAL_PREFIX}{a[1].upper()}_ROLLING5({v_name}.{a[0]})" ) # new_columns = [] # for a in tmp_u.columns: # if "collect_list" == a[1]: # new_columns.append(f"{'mul_'}{a[1].upper()}_ROLLING5({v_name}.{a[0]})") # else: # new_columns.append(f"{CONSTANT.NUMERICAL_PREFIX}{a[1].upper()}_ROLLING5({v_name}.{a[0]})") # # tmp_u.columns = new_columns # print(tmp_u.columns) ##-------------remove duplicated rolling columns--------------- c_tmp = None count = 0 for c in tmp_u.columns: if 'COUNT_ROLLING5' in c: if c_tmp is None: c_tmp = tmp_u[c] else: tmp_u.drop(c, axis=1, inplace=True) count += 1 print("There are %d duplicated columns in temporal join!" % count) # print(tmp_u.columns) # input() ##------------check whether all n_COUNT_ROLLING_X are the same--------------- '''all_columns = tmp_u.columns print(all_columns) c_tmp = None for c in all_columns: if 'COUNT_ROLLING5' in c: if c_tmp is None: c_tmp = tmp_u[c] else: print(c) print([(tmp_u[c]-c_tmp).max(), (tmp_u[c]-c_tmp).min()]) input()''' # print(tmp_u.columns) tmp_u.reset_index(0, inplace=True) ##-------------check NAN after aggregation functions---------- '''print(tmp_u.columns) #print(tmp_u["n_COUNT_ROLLING5(table_1.c_1)"]) for c in tmp_u.columns: print(c) print(tmp_u[c].loc['u'].shape[0]) print(np.sum(np.isnan(tmp_u[c]).loc['u'])) print(tmp_u[c].loc['u']) #print(tmp_u['n_MEAN_ROLLING5(table_1.n_1)']) input()''' if tmp_u.empty: log("empty tmp_u, return u") return u # print(u.shape,tmp_u.loc['u'].shape,tmp_u_2.shape) # ret = pd.concat([u, tmp_u.loc['u'],#tmp_u_2], axis=1, sort=False) # ret = pd.concat([u, tmp_u.loc['u']], axis=1, sort=False) index_tmp = u.index u["index"] = list(range(0, len(index_tmp))) ret = pd.merge(u, tmp_u, on=[key]) ret.sort_values("index", inplace=True) ret.index = index_tmp ret.drop("index", axis=1, inplace=True) timer.check("final concat") del tmp_u return ret else: ###------------ Multi-cat features will be processed in the main function --------## for c in [c for c in v if c.startswith(CONSTANT.MULTI_CAT_PREFIX)]: v[c].fillna("0", inplace=True) v["mul_feature_" + c] = v[c].apply(lambda x: str(x).split(",")) # v["mul_feature_" + c] = v[c].str.split(",") # print(v["mul_feature_" + c]) # v["mul_feature_" + c] = v[c] v[c] = v["mul_feature_" + c].apply(lambda x: int(x[0])) ''' for c in [c for c in v if c.startswith(CONSTANT.MULTI_CAT_PREFIX)]: v[c].fillna("0",inplace=True) mul_features = get_tfidf_vector(v[c], c) v.drop(c, axis=1, inplace=True) v = pd.concat([v, mul_features], axis=1) ''' # tmp_u = u[[time_col, key]] # tmp_u = pd.concat([tmp_u, v], keys=['u', 'v'], sort=False) # print(tmp_u[key].nunique()) # input() # print(u.dtypes) # input() # u[key] = u[key].astype('int64') v = v.set_index(key) v.columns = v.columns.map( lambda a: f"{a.split('_', 1)[0]}_{v_name}.{a}") return u.join(v, on=key)
class Level(object): '''This object is responsible for drawing the level and everything in it''' def __init__(self, filename, screen_width, screen_height): object.__init__(self) filename = level_path(filename) self.player = Player((50, 50)) self.camera = pygame.Rect((50,50), (screen_width, screen_height)) self.world_map = tiledtmxloader.TileMapParser().parse_decode(filename) resources = ResourceLoaderPygame() resources.load(self.world_map) self.renderer = RendererPygame(resources) self.renderer.set_camera_position_and_size(0, 0, screen_width, screen_height) self.renderer.set_camera_margin(0, 0, 0, 0) self.screen_width = screen_width self.screen_height = screen_height self.jump_timer = JumpTimer() self.jump_wait_timer = None self.input_state = None self._img_cache = {} self._img_cache["hits"] = 0 def restart(self): self.player.restart() def tile_magic(self, tile, allow_break=True): '''Handle special tiles''' #debug(tile) for special_tile in ('grow', 'shrink', 'narrow', 'widen'): if config.getint('Tiles', special_tile) == tile: getattr(self.player, special_tile)() return def collide_walls(self, ms): grounded = False for layer in self.world_map.layers: if layer.is_object_group: continue floor_tile = None for pos in self.player.bottom_collide_pts: tile = self.get_tile(pos, layer) if tile: # Move above this tile. # This assumes we are not completely overlapping a tile. # This should never happen if we limit movement to < 16px per frame floor_tile = tile self.player.displace(0, -(self.player.collide_rect.bottom % 16)) grounded = True break if floor_tile: self.tile_magic(floor_tile) if floor_tile == config.getint('Tiles', 'crack') and self.player.heavy: self.set_platform(pos, layer, config.getint('Tiles', 'break')) elif floor_tile == config.getint('Tiles', 'break') and self.player.heavy: self.set_platform(pos, layer, 0) # All floor tiles stop the players fall self.player.velocity = (self.player.velocity[0],0) top_points = self.player.top_collide_pts for pos in top_points: if grounded: break if self.get_tile(pos, layer): debug('collide top %s', pos) self.player.displace(0, 16) # move one tile down self.player.displace(0, -(self.player.collide_rect.top % 16)) # move to the top of the tile self.player.velocity = (self.player.velocity[0],0) break left_points = self.player.left_collide_pts for pos in left_points: if self.get_tile(pos, layer): debug('collide left %s', pos) self.player.displace(16, 0) self.player.displace(-(self.player.collide_rect.left % 16), 0) break right_points = self.player.right_collide_pts for pos in right_points: if self.get_tile(pos, layer): debug('collide right %s', pos) debug(self.get_tile(pos,layer)) self.player.displace(-(self.player.collide_rect.right % 16), 0) break # Update the jump timer which determines if it's possible to jump if grounded: self.jump_timer.set() else: self.jump_timer.update(ms) def get_tile(self, pos, layer): x,y = pos if x < 0 or y < 0 or x >= layer.pixel_width or y >= layer.pixel_height: raise OutOfBounds() x /= 16 y /= 16 tile = layer.decoded_content[x + y*layer.width] return tile def set_tile(self, pos, layer, tile): x,y = pos if x < 0 or y < 0 or x >= layer.pixel_width or y >= layer.pixel_height: raise OutOfBounds() x /= 16 y /= 16 layer.decoded_content[x + y*layer.width] = tile layer._gen_2D() def set_platform(self, pos, layer, tile): '''Set tile and horizontal neighbours''' x,y = pos current_tile = self.get_tile(pos, layer) platform = [pos] if x>=16: platform.append((x-16,y)) if x<layer.pixel_width-16: platform.append((x+16,y)) for pos2 in platform: if self.get_tile(pos2, layer) == current_tile: self.set_tile(pos2, layer, tile) def input_changed(self, action, state): x = 0 if state['left']: x = -1 elif state['right']: x = 1 self.player.set_direction(x) self.input_state = state if not state['up']: self.jump_wait_timer = None def tick(self, ms): self.player.move(ms) if self.player.collide_rect.left >= self.world_map.pixel_width - 16: debug('Level complete') return True # Handle collisions with walls/platforms try: self.collide_walls(ms) except OutOfBounds: debug('%s out of bounds', self.player.collide_rect) raise FellOffMap() # Check for jump every frame, in case user is holding down the button if not self.jump_wait_timer and self.input_state and self.input_state['up'] and self.jump_timer.jump_allowed(): debug('jump') self.jump_timer.unset() self.jump_wait_timer = Timer(config.getint('Physics','jump_wait_time')) # wait a bit between jumps self.player.start_jump() elif self.jump_wait_timer: if self.jump_wait_timer.check(ms): self.jump_wait_timer = None # Center camera on player self.camera.center = self.player.rect.center # Constrain camera to the level self.camera.right = min(self.camera.right, self.world_map.pixel_width) self.camera.bottom = min(self.camera.bottom, self.world_map.pixel_height) self.camera.left = max(self.camera.left, 0) self.camera.top = max(self.camera.top, 0) self.renderer.set_camera_position(self.camera.centerx, self.camera.centery) self.renderer.set_camera_margin(0, 0, 0, 0) # something is resetting the margin to 16px each frame... grrr def debug(self): debug('camera %s %s', self.camera.topleft,self.camera.bottomright) sprite_layers = self.renderer.get_layers_from_map() for sprite_layer in sprite_layers: debug('layer %s: margin %s, cam rect %s, render cam rect %s, paralax factor %s,%s', id(sprite_layer), self.renderer._margin, self.renderer._cam_rect, self.renderer._render_cam_rect, sprite_layer.paralax_factor_x, sprite_layer.paralax_factor_y) def screen_coordinates(self, pos): '''Convert world coordinates into screen coordinates''' x,y = pos return (x-self.camera.left, y-self.camera.top) def draw(self, screen): screen.fill((255,255,255)) sprite_layers = self.renderer.get_layers_from_map() for sprite_layer in sprite_layers: if sprite_layer.is_object_group: self._draw_obj_group(screen, sprite_layer, self.camera.left, self.camera.top) else: self.renderer.render_layer(screen, sprite_layer) screen.blit(self.player.image, self.player.rect.move((-self.camera.left, -self.camera.y)).topleft) if config.options.debug: pygame.draw.rect(screen, (255,0,0), self.player.collide_rect.move((-self.camera.left, -self.camera.y)), 1) pygame.display.flip() def _draw_obj_group(self, screen, obj_group, cam_world_pos_x, cam_world_pos_y, font=None): goffx = obj_group.x goffy = obj_group.y for map_obj in obj_group.objects: debug1('object at %d,%d', map_obj.x, map_obj.y) debug1('source %s, image %s', map_obj.image_source, map_obj.image) size = (map_obj.width, map_obj.height) if size == (0, 0): size = (16,16) if map_obj.image_source: surf = pygame.image.load(map_obj.image_source) surf = pygame.transform.scale(surf, size) screen.blit(surf, (goffx + map_obj.x - cam_world_pos_x, \ goffy + map_obj.y - cam_world_pos_y)) else: r = pygame.Rect(\ (goffx + map_obj.x - cam_world_pos_x, \ goffy + map_obj.y - cam_world_pos_y),\ size) pygame.draw.rect(screen, (255, 255, 0), r, 1)