def individual_bowling_game(pid):
min_value = 0
total_sets = 10
trial_3 = 0
pins = 10
game_scores = []
for game_set in range(total_sets):
if game_set == total_sets - 1:
trial_1, trial_2, trial_3 = Game.set_score(
min_value, total_sets, game_set, pins)
score = trial_1 + trial_2 + trial_3
else:
trial_1, trial_2 = Game.set_score(min_value, total_sets,
game_set, pins)
score = trial_1 + trial_2
bonus = Strategies.run_strategy(trial_1, trial_2)
set_total_score = score + bonus
if game_set == (total_sets - 1) and (trial_1 == pins or
(trial_1 + trial_2) == pins):
trial_scores = Game.three_trail_set(trial_1, trial_2, trial_3,
set_total_score)
else:
trial_scores = Game.two_trail_set(trial_1, trial_2,
set_total_score)
game_scores.append(trial_scores)
Player.players[pid]['game_scores'] = game_scores
Player.calculate_final_score(pid)
def run_moving_average_strategy(self):
"""
This method will run the moving average strategy.
It will call our other methods to:
- get the candlestick data
- process the candlestick data
- compute the buy and sell signals
- backtest the strategy
- plot the candlestick chart
Parameter:
Return:
- None
"""
binance = BinanceOperations(
) # Create instance of binance operations class
strategies = Strategies() # Create instance of strategies class
# Get candlestick data (with good dates to see signals, for test reasons)
# start_time = 1590624000000 # 28th of May 2020
# end_time = 1593302400000 # 28th of June 2020
# candlestick_data = binance.get_candlestick_data(self.symbol, start_time=start_time, end_time=end_time)
# Get candlestick data
candlestick_data = binance.get_candlestick_data(self.symbol)
# Process the candlestick data
candlestick_df = self.process_data(candlestick_data)
# Compute buy and sell signals:
signals = strategies.moving_average_strategy(candlestick_df,
quantity=1)
buy_signals = signals[0]
sell_signals = signals[1]
# Backtest the strategy
self.backtest_strategy(buy_signals, sell_signals)
# Plot the candlestick data as candlestick chart
self.plot_data(candlestick_df, buy_signals, sell_signals)
def compute_strategy(self, state, id_team, id_player):
s = Strategies(state, id_team, id_player)
v = SuperState(state, id_team, id_player)
a = Actions(state, id_team, id_player)
if v.player.distance(v.ball) < PLAYER_RADIUS + BALL_RADIUS:
shoot = v.playeradverse - v.player
return SoccerAction(shoot=shoot.normalize() * 3)
else:
return a.deplacement(v.ball)
def compute_strategy(self, state, id_team, id_player):
s = Strategies(state, id_team, id_player)
v = SuperState(state, id_team, id_player)
a = Actions(state, id_team, id_player)
if v.player.distance(v.ball) < PLAYER_RADIUS + BALL_RADIUS:
return a.tircoequippier
else :
if v.ballecampadverse == 0:
if id_team == 1 :
return a.deplacement(Vector2D((GAME_WIDTH/2)-5, v.ball.y))
else :
return a.deplacement(Vector2D((GAME_WIDTH/2)+5, v.ball.y))
else :
return a.deplacement(v.ball)
def compute_strategy(self, state, id_team, id_player):
s = Strategies(state, id_team, id_player)
v = SuperState(state, id_team, id_player)
a = Actions(state, id_team, id_player)
if v.player.distance(v.ball) < PLAYER_RADIUS + BALL_RADIUS:
if id_team == 1:
if v.player.x < GAME_WIDTH * 2 / 8:
shoot = Vector2D(GAME_WIDTH * 4 / 8, GAME_HEIGHT / 2)
return SoccerAction(shoot=shoot.normalize() * 3)
else:
if v.playeradverse.y < GAME_HEIGHT / 2:
shoot = Vector2D(GAME_WIDTH * 7.5 / 8,
GAME_HEIGHT * 3.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
shoot = Vector2D(GAME_WIDTH * 7.5 / 8,
GAME_HEIGHT * 0.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
if v.player.x > GAME_WIDTH * 6 / 8:
shoot = Vector2D(GAME_WIDTH * 4 / 8, GAME_HEIGHT / 2)
return SoccerAction(shoot=shoot.normalize() * 3)
else:
if v.playeradverse.y > GAME_HEIGHT / 2:
shoot = Vector2D(GAME_WIDTH * 0.5 / 8,
GAME_HEIGHT * 0.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
shoot = Vector2D(GAME_WIDTH * 0.5 / 8,
GAME_HEIGHT * 3.5 / 4) - v.player
return SoccerAction(shoot=shoot.normalize() * 100)
else:
if v.ballecampadverse == 0:
if id_team == 1:
return a.deplacement(
Vector2D(GAME_WIDTH * 2 / 8, GAME_HEIGHT / 2))
else:
return a.deplacement(
Vector2D(GAME_WIDTH * 6 / 8, GAME_HEIGHT / 2))
else:
return a.deplacement(v.ball)
def calculate_returns(day_skip = 4000):
starting_amount = 100_000
start = '1970-01-02'
end = '2019-12-31'
dividend_dates = [4,7,10,12]
capital_dates = [4, 12]
dividend_tax = 0.15
capital_tax = 0.15
capital_annual_yield = 0.001
annual_fund_fees = 0.00015
drop_pct_threshold = 0.2
rise_pct_threshold = 0.6
buy_pct = 0.4
sell_pct = 0.1
data = download_data()
#Get backtesting data object
d = Data_Handler(data, starting_amount, start, end, dividend_dates, capital_dates, dividend_tax,
capital_tax, capital_annual_yield, annual_fund_fees)
#Create backtesting data object.
clean_data = Strategies(d, drop_pct_threshold, rise_pct_threshold, buy_pct, sell_pct)
return_dict_fi = {}
return_dict_shbl = {}
starting_amount = clean_data.data.starting_amount
for i in tqdm(range(0,len(clean_data.data.df), day_skip)):
temp_d = deepcopy(clean_data)
new_start_date = temp_d.data.df.Date.iloc[i]
temp_d.data.df = temp_d.data.df[temp_d.data.df['Date'] >= new_start_date].reset_index()
temp_d.data.max_price = temp_d.data.min_price = temp_d.data.df.iloc[0]['Price']
temp_d.sell_high_buy_low_strat()
temp_d.fully_invested_strat()
ending_value_fi = temp_d.data.df.tail(1)['fi_Value'].iloc[0]
ending_value_shbl = temp_d.data.df.tail(1)['shbl_Value'].iloc[0]
ending_date = temp_d.data.df.tail(1)['Date'].iloc[0]
year_diff = (ending_date - new_start_date) / datetime.timedelta(days=365)
annualized_return_fi = (ending_value_fi / starting_amount) **(1/year_diff) - 1
annualized_return_shbl = (ending_value_shbl / starting_amount) **(1/year_diff) - 1
return_dict_fi[str(new_start_date)[:10]] = annualized_return_fi
return_dict_shbl[str(new_start_date)[:10]] = annualized_return_shbl
return_data = {'Fully_invested': return_dict_fi, 'Sell_high_buy_low': return_dict_shbl}
return_data = pd.DataFrame.from_dict(return_data)
fi_mean = round(np.mean(return_data.Fully_invested),3)
shbl_mean = round(np.mean(return_data.Sell_high_buy_low),3)
sns.boxplot(data=return_data).set_title("Box plot based upon {} different starting dates"\
.format(len(return_data)))
plt.legend(loc = 'upper right', labels=['FI: mean ' + str(fi_mean), 'SHBL: mean ' \
+ str(shbl_mean)], prop={'size': 9})
return return_data
elif (opt == 8):
print('You made the best choice and didn\'t play\n')
exit()
# Roulette Settings
roulette.configurePlayer()
# Strategy Name selection from a Strategies' Names array
allStrategies = [
"exit", "number", "color", "sofovich", "martingale", "dalembert",
"fibonacci", "sante", "noplay"
]
stratName = allStrategies[opt]
# Configuring strategy parameters
strat = Strategies(roulette, stratName)
print()
# Arrays for multiple Game Results (Recommended: 5 to 10)
results = 6
resultsLimited = []
resultsUnlimited = []
# Simulating the Strategy
for i in range(results):
if (opt == 1): graphsLim, graphsUnlim = strat.betToNumber()
elif (opt == 2):
graphsLim, graphsUnlim = strat.betToColor()
elif (opt == 3):
graphsLim, graphsUnlim = strat.betAsSofovich()
elif (opt == 4):
async def perform_strategy(self, iteration, strategy_num):
self.mainAgent.clean_strike_force(
) # Clear dead units from strike force
self.mainAgent.is_army_cached = False # Must re obtain army data
if self.mainAgent.predicted_enemy_position_num == -1:
# Initializing things that are needed after game data is loaded
# Prevent game from crashing
hatchery = self.mainAgent.bases
if hatchery == None or hatchery.amount == 0:
return
else:
hatchery = self.mainAgent.bases.ready.random
# Assume first position
self.mainAgent.predicted_enemy_position = 0
self.mainAgent.num_enemy_positions = len(
self.mainAgent.enemy_start_locations)
self.mainAgent.start_location = self.mainAgent.bases.ready.random.position # Should only be 1 hatchery at this time
self.mainAgent.map_width = self.mainAgent.game_info.map_size[0]
self.mainAgent.map_height = self.mainAgent.game_info.map_size[1]
# Get a point in the corner of the map
p = lambda: None # https://stackoverflow.com/questions/19476816/creating-an-empty-object-in-python
p.x = self.mainAgent.game_info.map_center.x * 1.9
p.y = self.mainAgent.game_info.map_center.y * 1.9
self.mainAgent.map_corner = Point2.from_proto(p)
# Make sure given strategy num is valid
if Strategies.has_value(strategy_num):
# Valid strategy num, convert int into enum value
strategy = Strategies(strategy_num)
# Mark strategy as changed or not
if strategy != self.mainAgent.prev_strategy:
self.mainAgent.log("New strategy is " + str(strategy))
self.mainAgent.did_strategy_change = True
self.mainAgent.strike_force = None
else:
self.mainAgent.did_strategy_change = False
self.mainAgent.prev_strategy = strategy # Prepare for next iteration
else:
self.log_error(f"Unknown strategy number {strategy_num}")
return
# Call the proper strategy function
# Prevent game from crashing
hatchery = self.mainAgent.bases
if hatchery == None or hatchery.amount == 0:
return
else:
hatchery = self.mainAgent.bases.ready.random
# Attack
if strategy == Strategies.HEAVY_ATTACK:
await self.heavy_attack(iteration)
elif strategy == Strategies.MEDIUM_ATTACK:
await self.medium_attack(iteration)
elif strategy == Strategies.LIGHT_ATTACK:
await self.light_attack(iteration)
# Scouting
elif strategy == Strategies.HEAVY_SCOUTING:
await self.heavy_scouting(iteration)
elif strategy == Strategies.MEDIUM_SCOUTING:
await self.medium_scouting(iteration)
elif strategy == Strategies.LIGHT_SCOUTING:
await self.light_scouting(iteration)
# Defense
elif strategy == Strategies.HEAVY_DEFENSE:
await self.heavy_defense(iteration)
elif strategy == Strategies.MEDIUM_DEFENSE:
await self.medium_defense(iteration)
elif strategy == Strategies.LIGHT_DEFENSE:
await self.light_defense(iteration)
# Harass
elif strategy == Strategies.HEAVY_HARASS:
await self.heavy_harass(iteration)
elif strategy == Strategies.MEDIUM_HARASS:
await self.medium_harass(iteration)
elif strategy == Strategies.LIGHT_HARASS:
await self.light_harass(iteration)
# Unknown
else:
self.log("Unknown strategy was given: " + str(strategy))