def __makeChange(self, value):
excess = self.getTotal() - value
for aCoin in self.inserted:
if aCoin.getValue() == Coins.QUARTER_VALUE:
self.quarters += 1
elif aCoin.getValue() == Coins.DIME_VALUE:
self.dimes += 1
elif aCoin.getValue() == Coins.NICKEL_VALUE:
self.nickels += 1
self.inserted = []
quarters = int(excess / Coins.QUARTER_VALUE)
if quarters > 0:
excess = round(excess - (Coins.QUARTER_VALUE * quarters), 2)
for i in range(quarters):
self.coinReturn.append(Coin(Coins.QUARTER_WEIGHT, Coins.QUARTER_DIAMETER))
self.quarters -= 1
dimes = int(round(excess / Coins.DIME_VALUE))
if dimes > 0:
excess = round(excess - (Coins.DIME_VALUE * dimes), 2)
for i in range(dimes):
self.coinReturn.append(Coin(Coins.DIME_WEIGHT, Coins.DIME_DIAMETER))
self.dimes -= 1
nickels = int(excess / Coins.NICKEL_VALUE)
if nickels > 0:
excess = round(excess - (Coins.NICKEL_VALUE * nickels), 2)
for i in range(nickels):
self.coinReturn.append(Coin(Coins.NICKEL_WEIGHT, Coins.NICKEL_DIAMETER))
self.nickels -= 1
def __init__(self, _MIN_VALUE=_MIN, _MAX_VALUE=_MAX):
#valeurs pour les sentinelles, -infini à +infini
self._MIN_VALUE = _MIN_VALUE
self._MAX_VALUE = _MAX_VALUE
#une instance de Coin pour les tours de hauteurs variables
self._coin = Coin()
#hauteur de départ
self._height = 1
#taille initiale de 0
self._size = 0
#les 4 sentinelles et leurs interrelations
#lr = low-right; ll = low-left; ul = upper-left; ur = upper-right
sentinel_lr = SkipListNode(self._MAX_VALUE)
sentinel_ll = SkipListNode(self._MIN_VALUE, None, sentinel_lr, None,
None)
sentinel_lr._prev = sentinel_ll
sentinel_ul = SkipListNode(self._MIN_VALUE, None, None, sentinel_ll,
None)
sentinel_ur = SkipListNode(self._MAX_VALUE, sentinel_ul, None,
sentinel_lr, None)
sentinel_ul._next = sentinel_ur
sentinel_ll._abov = sentinel_ul
sentinel_lr._abov = sentinel_ur
#par convention, le début de la skiplist est la sentinelle _ul
self._start = sentinel_ul
def testWhenCoinIsPassedInvalidWeightAndDiameterTheCoinIsInvalidAndHasProvidedWeightAndDiameter(
self):
aCoin = Coin(2.5, 0.75) # A penny
self.assertEqual(aCoin.isValid(), False)
self.assertEqual(aCoin.getWeight(), 2.5)
self.assertEqual(aCoin.getDiameter(), 0.75)
def insert(self, weight, diameter):
aCoin = Coin(weight, diameter)
if aCoin.isValid():
self.inserted.append(aCoin)
else:
self.coinReturn.append(aCoin)
return aCoin.isValid()
def create_coin(self):
# Generate unique coin id
c = Coin(self._current_id)
# Sign by scrooge
c.sign(self._sk.sign(str(c).encode('utf-8')))
self._current_id += 1
self._coins.append(c)
# Add coin to block chain, as owned by Scrooge user
self._ledger._users_coins[self.vk].append(c)
def get_answer(request_type):
if '코인' in request_type:
obj_coin = Coin()
return obj_coin.getCoinInfo()
elif '원티드' in request_type:
obj_wanted = Wanted()
return obj_wanted.getWantedInfo()
elif '프로그래머스' in request_type:
obj_prgrammers = Programmers()
return obj_prgrammers.getProgrammersInfo()
return default_answer
def Destroy(self):
self.dead = True
self.game.needs_sorting = True
self.game.game_objects.remove(self)
self.game.enemy_generator.spawned_bear = False
self.game.enemy_generator.bear_timer = 20
# self.game.enemy_generator.rebear += 1
if not self.game.player.dead:
self.game.NextLevel()
for i in range(DROPS_COINS):
coin = Coin(self.game)
x, y = RandomPointInCircle(self.radius)
coin.x = self.x + x
coin.y = self.y + y
self.game.AddObject(coin)
def createCoins(self,values,issuerurl):
"""requests a coin of a value from the specified issuer
"""
issuer = self.issuers[issuerurl]
if type(values) != type([]):
values, rest = partition(issuer.getPubKeys().keys(),int(values))
for v in values:
#create blanks
coin = Coin(issuer.getUrl(),decodeKey(issuer.getPubKeys_encoded()[str(v)]),v)
blind = coin.getBlind()
hash = coin.getHash()
self.coins[hash] = coin
self.pending[hash] = coin
def __init__( self, _MIN_VALUE = -999999999, _MAX_VALUE = 999999999 ):
self._MIN_VALUE = _MIN_VALUE
self._MAX_VALUE = _MAX_VALUE
self._coin = Coin()
self._height = 1
self._count = 0
sentinel_lr = SkipListNode( self._MAX_VALUE )
sentinel_ll = SkipListNode( self._MIN_VALUE, None, sentinel_lr, None, None )
sentinel_lr._prev = sentinel_ll
sentinel_ul = SkipListNode( self._MIN_VALUE, None, None, sentinel_ll, None )
sentinel_ur = SkipListNode( self._MAX_VALUE, sentinel_ul, None, sentinel_lr, None )
sentinel_ul._next = sentinel_ur
sentinel_ll._abov = sentinel_ul
sentinel_lr._abov = sentinel_ur
self._start = sentinel_ul
def createCoins(self, values, issuerurl):
"""requests a coin of a value from the specified issuer
"""
issuer = self.issuers[issuerurl]
if type(values) != type([]):
values, rest = partition(issuer.getPubKeys().keys(), int(values))
for v in values:
#create blanks
coin = Coin(issuer.getUrl(),
decodeKey(issuer.getPubKeys_encoded()[str(v)]), v)
blind = coin.getBlind()
hash = coin.getHash()
self.coins[hash] = coin
self.pending[hash] = coin
def createCoins(win):
# Create 100 points and add them to a list
# Init list
coins = list()
# Each row
for i in range(5, 100, 10):
# Each column
for j in range(5, 100, 10):
pt = Point(i, j)
if i == 95 and j == 95:
c = Coin(win, pt, True)
else:
c = Coin(win, pt, False)
coins.append(c)
return coins
def setCoins():
global listCoins, level
# hashtag Set list of coins depending on the current level
listCoins = [0] * len(CoinDimensions[level])
# hashtag Iterate through the parameters of each coin for the current level and initialize Coin class object
for index in range(len(listCoins)):
dimensions = CoinDimensions[level][index]
listCoins[index] = Coin(canvas, dimensions[0], dimensions[1])
class TestCoin(unittest.TestCase):
def setUp(self):
self.values = ['heads', 'tails']
self.test_coin = Coin()
def test_instance_creation(self):
"""
Test that the the test_coin object created is indeed an instance of a Coin
:return:
"""
self.assertIsInstance(self.test_coin, Coin)
def test_face_value_init(self):
self.assertIn(self.test_coin.face, self.values)
def test_get_face(self):
self.assertIn(self.test_coin.get_face(), self.values)
def test_flip(self):
self.test_coin.flip()
self.assertIn(self.test_coin.get_face(), self.values)
def init_gamestates(self):
self.gamestates = list()
all_sprites = pygame.sprite.Group()
P1 = Player(self.DISPLAYSURF)
E1 = Obstacle(self.DISPLAYSURF, self.speed, 40, 70, 0)
E2 = Obstacle(self.DISPLAYSURF, self.speed, 405, 50, -350)
C1 = Coin(self.DISPLAYSURF, self.speed, 20, 20, 700)
all_sprites.add(P1, E1, E2, C1)
state = Gamestate(self.DISPLAYSURF, self.speed, 0, 0, all_sprites)
for i in range(self.pop_size):
self.gamestates.append(state.copy())
def __makeChangeFromPennies(self, input):
coins = [
Coin("£2", 200),
Coin("£1", 100),
Coin("50p", 50),
Coin("20p", 20),
Coin("10p", 10),
Coin("5p", 5),
Coin("2p", 2),
Coin("1p", 1)
]
statements = []
statements = self.__findCoinCountForEachCoin(input, coins, statements)
# statements = self.__createCoinStatements(coins)
return self.__buildOutputString(statements)
def make_coin_obj(row):
'''
INPUT: row (row) - the row from a pandas dataframe
OUTPUT: a Coin object that keeps track of all information
'''
name = row['COIN_NAME']
quantity = float(row['BUY_QUANTITY'])
buy_currency = row['BUY_CURRENCY']
buy_price = float(row['BUY_PRICE'])
coin = Coin(name=name,
buy_price=buy_price,
quantity=quantity,
buy_currency=buy_currency)
return coin
def Update(self):
# get the distance the players moved since we last spawned something
d = Distance(self.last_spawn_position_x, self.last_spawn_position_y,
self.game.player.x, self.game.player.y)
self.warm_up_time += self.game.delta_time
if d > self.spawn_rate and self.warm_up_time > WARM_UP:
# then we'll spawn something
# create a random point in front of the player, outside of the screen
vx = self.game.player.x - self.last_spawn_position_x
vy = self.game.player.y - self.last_spawn_position_y
rx, ry = RandomVector(vx, vy, self.scatter_angle_variance,
self.scatter_spawning_distance,
self.distance_variance)
newx = self.game.player.x + rx
newy = self.game.player.y + ry
coin = Coin(self.game)
coin.x = newx
coin.y = newy
self.game.AddObject(coin)
# finalize
self.last_spawn_position_x = self.game.player.x
self.last_spawn_position_y = self.game.player.y
if not self.first_time_pop_up:
floating_text = FloatingText.New(self.game, (255, 255, 255),
"Collect $ to",
self.game.width * 0.6,
self.game.height * 0.2,
line2="upgrade weapon",
target_object=coin)
self.game.AddObject(floating_text)
self.first_time_pop_up = True
def GenerateCoins(self):
for i in range(6, len(self.map)):
for j in range(len(self.map[i])):
if self.map[i][j] == 0 and ((i + 1 < len(self.map) and self.map[i + 1][j] == 1) or (
i + 2 < len(self.map) and self.map[i + 2][j] == 1)):
randNumber = math.floor(random.random() * 1000)
if randNumber % 35 == 0 and len(self.Coins) <= 25: # At max there will be 26 coins in the map
self.map[i][j] = 3
if j - 1 >= 0 and self.map[i][j - 1] == 3:
self.map[i][j] = 0
if self.map[i][j] == 3:
# Add the coin to our coin list
self.Coins.append(Coin(pygame.image.load('Assets/coin1.png'), (j * 15 + 15 / 2, i * 15 + 15 / 2)))
if len(self.Coins) <= 20: # If there are less than 21 coins, we call the function again
self.GenerateCoins()
def GenerateCoins(self):
for i in range(6, len(self.map)):
for j in range(len(self.map[i])):
if self.map[i][j] == 0 and ((i + 1 < len(self.map) and self.map[i + 1][j] == 1) or (
i + 2 < len(self.map) and self.map[i + 2][j] == 1)):
randNumber = math.floor(random.random() * 1000)
if randNumber % 35 == 0 and len(self.Coins) <= 25: # Se va a crear un maximo de 26 monedas
self.map[i][j] = 3
if j - 1 >= 0 and self.map[i][j - 1] == 3:
self.map[i][j] = 0
if self.map[i][j] == 3:
# agregar un coin a nuestro grupo
self.Coins.append(Coin(pygame.image.load('Assets/Apple.png'), (j * 15 + 15 / 2, i * 15 + 15 / 2)))
if len(self.Coins) <= 20: # si estan menos de 21 coins el programa se vuelva a generar
self.GenerateCoins()
def update(self, *args):
if self.hp <= 0:
self.all_sprites.add(
Coin(self.rect.x / 50, self.rect.y / 50, self.hero))
self.kill()
self.hero.kills += 1
return
self.shooting(self.hero, self.rect.x, self.rect.y)
x = self.hero.rect.x + self.hero.rect.w // 2
y = self.hero.rect.y + self.hero.rect.h // 2
rel_x, rel_y = x - self.rect.x, y - self.rect.y
angle = (180 / math.pi) * -math.atan2(rel_y, rel_x)
self.image, self.rect = rotate(self.frame, self.rect, int(angle))
def __init__(self):
"""Generate the level"""
self.sprite_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
self.width = 0
# Open the level
f = open('Levels/1-1.lvl', 'r')
# Create all blocs
for y, line in enumerate(self.reverse_lines(f)):
line = self.split(line.rstrip('\n'))
for x, value in enumerate(line):
self.width += 16 * SPRITE_SCALE
if value != '0':
bloc = None
if value == '1':
bloc = arcade.Sprite('Sprites/bloc.png', SPRITE_SCALE)
elif value == '2':
bloc = arcade.Sprite('Sprites/Box.png', SPRITE_SCALE)
elif value == '3':
bloc = arcade.Sprite('Sprites/mysterybox.png',
SPRITE_SCALE)
elif value == '4':
bloc = arcade.Sprite('Sprites/pipe_tl.png',
SPRITE_SCALE)
elif value == '5':
bloc = arcade.Sprite('Sprites/pipe_tr.png',
SPRITE_SCALE)
elif value == '6':
bloc = arcade.Sprite('Sprites/pipe_dl.png',
SPRITE_SCALE)
elif value == '7':
bloc = arcade.Sprite('Sprites/pipe_dr.png',
SPRITE_SCALE)
elif value == '8':
# Creae a new coin
self.coin_list.append(Coin(x, y))
continue
# Set bloc base data
bloc.center_x = x * bloc.width
bloc.center_y = y * bloc.height
self.sprite_list.append(bloc)
def deposit(self, currency, user_addr, deposit_token, val=0):
if currency == "BTC":
if isinstance(deposit_token, BTCToken):
if user_addr in self.btc_valid_tokens:
self.btc_valid_tokens[user_addr].append(deposit_token)
else:
self.btc_valid_tokens[user_addr] = [deposit_token]
self.send_deposit_token(user_addr, deposit_token)
else:
raise ValueError("Provided deposit token is not a BTCToken")
elif currency == "ETH":
if isinstance(deposit_token, ETHToken):
for i in range(self.N):
self.global_coin_id += 1
new_coin = Coin(self.global_coin_id, 0, (val / self.N))
deposit_token.coins.append(new_coin)
if user_addr in self.eth_valid_tokens:
self.eth_valid_tokens[user_addr].append(deposit_token)
else:
self.eth_valid_tokens[user_addr] = [deposit_token]
self.send_deposit_token(user_addr, deposit_token)
else:
ValueError("Provided deposit token is not a ETHToken")
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and game_active:
bird_yvelocity = -3
flap_sound.play()
elif event.key == pygame.K_SPACE and not game_active:
game_active = True
bird_rect.center = (50, int(screen_h/2))
bird_yvelocity = 0
coins.clear()
pipes.clear()
score = 0
if event.type == SPAWNCOIN and game_active:
rdm_coin_pos = random.choice(coin_pos)
new_coin = Coin(top_pipe_surface, (400, rdm_coin_pos))
coins.append(new_coin)
if event.type == COINFLIP and game_active:
coin_index += 1
if coin_index >= len(coin_frames):
coin_index = 1
for coin in coins:
coin.surface = coin_frames[coin_index]
coin.rect = coin.surface.get_rect(center=(int(coin.rect.centerx), int(coin.rect.centery)))
if event.type == BIRDFLAP and game_active:
bird_index += 1
if bird_index >= len(bird_frames):
bird_index = 0
bird_surface = bird_frames[bird_index]
def testWhenCoinIsPassValidWeightAndDiameterTheCoinIsValidAndHasProvidedWeightAndDiameter(
self):
nickel = Coin(Coins.NICKEL_WEIGHT, Coins.NICKEL_DIAMETER) # A nickel
self.assertEqual(nickel.isValid(), True)
self.assertEqual(nickel.getWeight(), Coins.NICKEL_WEIGHT)
self.assertEqual(nickel.getDiameter(), Coins.NICKEL_DIAMETER)
self.assertEqual(nickel.getValue(), Coins.NICKEL_VALUE)
dime = Coin(Coins.DIME_WEIGHT, Coins.DIME_DIAMETER) # A dime
self.assertEqual(dime.isValid(), True)
self.assertEqual(dime.getWeight(), Coins.DIME_WEIGHT)
self.assertEqual(dime.getDiameter(), Coins.DIME_DIAMETER)
self.assertEqual(dime.getValue(), 0.1)
quarter = Coin(Coins.QUARTER_WEIGHT,
Coins.QUARTER_DIAMETER) # A quarter
self.assertEqual(quarter.isValid(), True)
self.assertEqual(quarter.getWeight(), Coins.QUARTER_WEIGHT)
self.assertEqual(quarter.getDiameter(), Coins.QUARTER_DIAMETER)
self.assertEqual(quarter.getValue(), Coins.QUARTER_VALUE)
print(die1.list_of_rolls)
for i, freq in zip(range(len(die1.freq_list)), die1.freq_list):
print(f'{i+1}:{freq}', end='\t')
else:
print('Sorry, you have to roll the die at least once!')
else:
print('Sorry, the die must have at least 3 sides!')
elif choice == str(2):
num_flips = input('How many times do you want to flip the coin? ')
try:
num_flips = int(num_flips)
except ValueError:
print('Sorry, that wasn\'t a number!')
continue
if num_flips >= 1:
coin1 = Coin(num_flips)
coin1.flip()
coin1.flip_stats()
print(coin1.list_of_flips)
print(f'Heads: {coin1.freq_list[0]}\tTails: {coin1.freq_list[1]}')
else:
print('Sorry, you have to flip the coin at least once!')
elif choice == str(3):
num_draws = input('How many cards do you want to draw? ')
try:
num_draws = int(num_draws)
except ValueError:
print('Sorry, that wasn\'t a number!')
continue
if 1 <= num_draws <= 52:
card1 = Card(num_draws)
def volatility_strategy(coins_name: list):
os.makedirs('logs', exist_ok=True)
print(f'{get_now_time()} 시작가: {get_krw():.2f}')
print_order_config(config.items(section="VB_ORDER"))
coin_dict = dict()
for coin_name in coins_name:
coin_dict[coin_name] = Coin(coin_name)
while True:
for i, coin in enumerate(coin_dict.values()):
candles = get_candles('KRW-' + coin.coin_name,
count=2,
minute=UNIT,
candle_type=CANDLE_TYPE)
coin.high_price = max(candles[0]["trade_price"], coin.high_price)
now = candles[0]['candle_date_time_kst']
if coin.state == State.BOUGHT:
coin.earnings_ratio = (
candles[0]["trade_price"] -
coin.avg_buy_price) / candles[0]["trade_price"] * 100
coin.max_earnings_ratio = max(coin.earnings_ratio,
coin.max_earnings_ratio)
if coin.state == State.WAIT:
print(
f'{get_now_time()} {coin.coin_name:>6}({set_state_color(coin.state)})| '
f'목표 가: {coin.buy_price:>11.2f}, 현재 가: {candles[0]["trade_price"]:>10}'
f' ({set_dif_color(candles[0]["trade_price"], coin.buy_price)}) '
f'최대 {coin.max_earnings_ratio:>6.2f} %')
elif coin.state == State.BOUGHT:
print(
f'{get_now_time()} {coin.coin_name:>6}({set_state_color(coin.state)})| '
f'구매 가: {coin.avg_buy_price:>11.2f}, 현재 가: {candles[0]["trade_price"]:>10}'
f' ({set_dif_color(candles[0]["trade_price"], coin.avg_buy_price)}) '
f'최대 {coin.max_earnings_ratio:6.2f} %')
# 매도 조건
# 1. 시간 캔들이 바뀐 경우
# 2. 수익률이 5 % 이상인 경우
if coin.check_time != now or (coin.state == State.BOUGHT and coin.earnings_ratio >= 5)\
or (coin.state == State.BOUGHT and coin.earnings_ratio <= -5):
print(f'1. time_change: {coin.check_time != now} '
f'2. ratio: {coin.earnings_ratio}')
if coin.check_time != now and i == 0:
print(
f'----------------------------------- UPDATE ---------------------------------------'
)
if coin.state == State.BOUGHT:
sell_result = coin.sell_coin()
print(
f'\033[104m{get_now_time()} {coin.coin_name:>6}( SELL)| {int(round(get_sell_price(sell_result)))}원\033[0m'
)
if coin.check_time != now:
coin.state = State.WAIT
coin.max_earnings_ratio = 0
coin.earnings_ratio = 0
if coin.check_time != now and i == len(coin_dict) - 1:
print(
f'---------------------------------------------------------------------------------'
)
coin.check_time = now
coin.variability = candles[1]['high_price'] - candles[1][
'low_price']
coin.buy_price = candles[0][
"opening_price"] + coin.variability * (PERCENT_BUY_RANGE /
100)
coin.high_price = candles[0]["opening_price"]
coin.buy_balance = cal_buy_balance(coin.variability,
coin.high_price)
if coin.buy_balance == 0:
coin.state = State.PASS
print(
f'{coin.coin_name}| variability:{coin.variability}, buy_price:{coin.buy_price}, buy_balance:{coin.buy_balance}'
)
else: # 시간이 동일하다면
if coin.state != State.WAIT:
continue
if coin.variability == 0 or candles[0][
'trade_price'] <= coin.buy_price:
continue
# 매수
buy_result = coin.buy_coin(price=coin.buy_balance)
if not buy_result:
continue
print(
f'\033[101m{get_now_time()} {coin.coin_name:>6}( BUY)| {coin.bought_amount}원\033[0m'
)
def build_level(self, Level):
# build the level
self.player_list.empty()
self.player = Level().player
self.player_list.add(self.player)
self.player.ball_list = pygame.sprite.Group()
self.invincible_enemy_list.empty()
self.jump_blocks_list.empty()
self.exit_blocks_list.empty()
self.kill_blocks_list.empty()
self.fake_blocks_list.empty()
self.coin_list.empty()
self.enemy_list.empty()
self.platform_list.empty()
self.enemy_platform_list.empty()
self.enemy_list.add(Level().enemies)
self.invincible_enemy_list.add(Level().invincible_enemies)
x = y = 0
for row in Level().level:
for col in row:
if col == "P":
p = Platform(x, y)
self.platform_list.add(p)
#self.enemy_platform_list.add(p)
if col == "R":
r = EnemyPlatform(x, y)
self.platform_list.add(r)
self.enemy_platform_list.add(r)
if col == "X":
e = ExitBlock(x, y)
self.exit_blocks_list.add(e)
if col == "J":
j = JumpBlock(x, y)
self.jump_blocks_list.add(j)
if col == "S":
s = Structure(x, y)
self.platform_list.add(s)
if col == "Q":
q = EnemyStructure(x, y)
self.platform_list.add(q)
self.enemy_platform_list.add(q)
if col == "K":
k = KillBlock(x, y)
self.kill_blocks_list.add(k)
#self.enemy_platform_list.add(k)
if col == "I":
i = InvisibleBlock(x, y)
self.enemy_platform_list.add(i)
if col == "B":
b = Brick(x, y)
self.platform_list.add(b)
#self.enemy_platform_list.add(b)
if col == "U":
u = KillBlock2(x, y)
self.kill_blocks_list.add(u)
self.enemy_platform_list.add(u)
if col == "E":
e = Enemy(x, y, 'normal')
self.enemy_list.add(e)
if col == "Z":
z = Enemy(x, y, 'invincible')
self.invincible_enemy_list.add(z)
if col == "C":
c = Coin(x, y)
self.coin_list.add(c)
if col == "F":
f = FakePlatform(x, y)
self.fake_blocks_list.add(f)
x += PLATFORM_WIDTH
y += PLATFORM_HEIGHT
x = 0
self.total_level_width = len(Level().level[0]) * PLATFORM_WIDTH
self.total_level_height = len(Level().level) * PLATFORM_HEIGHT
def short_volatility_strategy(coins_name: list):
print_order_config(config.items(section="VB_ORDER"))
coin_dict = dict()
for coin_name in coins_name:
coin_dict[coin_name] = Coin(coin_name)
while True:
for coin in coin_dict.values():
candles = get_candles('KRW-' + coin.coin_name,
count=2,
minute=unit)
now = candles[0]['candle_date_time_kst']
print(
f'{get_now_time()} {coin.coin_name}({set_state_color(coin.state)})| '
f'목표 가: {coin.buy_price:>11.2f}, 현재 가: {candles[0]["trade_price"]:>10}'
f' ({set_dif_color(candles[0]["trade_price"], coin.buy_price)})'
)
if coin.check_time != now:
print(f'{coin.check_time} -> \033[36m{now}\033[0m')
if coin.state == State.BOUGHT or coin.state == State.TRYBUY:
sell_result = coin.sell_coin()
if sell_result == "Not bought":
print(
f'\033[100m{get_now_time()} {coin.coin_name}( ERROR)|\033[0m'
)
else:
print(
f'\033[104m{get_now_time()} {coin.coin_name}( SELL)| '
f'{int(get_sell_price(access_key))}\033[0m')
with open("../logs/VB_order.log", "a") as f:
f.write(
f'{get_now_time()} {coin.coin_name}( SELL)| '
f'{int(get_sell_price(access_key))}원\n')
if coin.state == State.TRYBUY:
coin.cansel_buy()
print(
f'\033[104m{get_now_time()} {coin.coin_name}( CANCEL)|\033[0m'
)
coin.check_time = now
coin.variability = candles[1]['high_price'] - candles[1][
'low_price']
coin.buy_price = candles[0][
"opening_price"] + coin.variability * (percent_buy_range /
100)
else: # 시간이 동일하다면
if coin.state == State.BOUGHT or coin.variability == 0:
continue
if candles[0]['trade_price'] <= coin.buy_price:
continue
# 매수
limit = True
buy_result = coin.buy_coin(price=10000, limit=limit)
os.makedirs('../logs', exist_ok=True)
if limit:
print(
f'\033[95m{get_now_time()} {coin.coin_name}(TRYBUY)| '
f'{buy_result.get("locked"):>6}원\033[0m')
with open("../logs/VB_order.log", "a") as f:
f.write(f'{get_now_time()} {coin.coin_name}(TRYBUY)| '
f'{buy_result.get("locked"):>6}원\033[0m')
else:
print(
f'\033[101m{get_now_time()} {coin.coin_name}( BUY)| '
f'{int(get_buy_price(coin.coin_name))}원\033[0m')
with open("../logs/VB_order.log", "a") as f:
f.write(f'{get_now_time()} {coin.coin_name}( BUY)| '
f'{int(get_buy_price(coin.coin_name))}원\n')
class SkipList():
def __init__(self, _MIN_VALUE=_MIN, _MAX_VALUE=_MAX):
#valeurs pour les sentinelles, -infini à +infini
self._MIN_VALUE = _MIN_VALUE
self._MAX_VALUE = _MAX_VALUE
#une instance de Coin pour les tours de hauteurs variables
self._coin = Coin()
#hauteur de départ
self._height = 1
#taille initiale de 0
self._size = 0
#les 4 sentinelles et leurs interrelations
#lr = low-right; ll = low-left; ul = upper-left; ur = upper-right
sentinel_lr = SkipListNode(self._MAX_VALUE)
sentinel_ll = SkipListNode(self._MIN_VALUE, None, sentinel_lr, None,
None)
sentinel_lr._prev = sentinel_ll
sentinel_ul = SkipListNode(self._MIN_VALUE, None, None, sentinel_ll,
None)
sentinel_ur = SkipListNode(self._MAX_VALUE, sentinel_ul, None,
sentinel_lr, None)
sentinel_ul._next = sentinel_ur
sentinel_ll._abov = sentinel_ul
sentinel_lr._abov = sentinel_ur
#par convention, le début de la skiplist est la sentinelle _ul
self._start = sentinel_ul
#taille de la skiplist
def __len__(self):
return self._size
# prettyprint
def __str__(self):
#on prend le début de la skiplist
current = self._start
pp = "SkipList of height " + str(self._height) + ":\n"
#pour chaque niveau
for level in range(self._height, -1, -1):
p = current
pp += "level " + str(level) + " ["
#le premier élément du niveau est le suivant de la sentinelle
p = p._next
while not (p is None):
if (not p._next is None):
pp += str(p._elem)
if (not p._next._next is None):
pp += ","
p = p._next
#on descend par la sentinelle
current = current._belo
pp += "]\n"
return pp
#iterateur : parcours les éléments du niveau 0
def __iter__(self):
#on prend le niveau du début de la skiplist (plus haut)
level = self._start
#on descend jusqu'au niveau 0 par les sentinelles
while not (level._belo is None):
level = level._belo
#on parcourt les éléments du niveau 0,
#le premier étant le suivant de la sentinelle
current = level._next
while not (current._next is None):
yield current._elem
current = current._next
#retourne l'élément le plus petit de la skiplist
def Min(self):
#si la skiplist est vide, il n'existe pas
if self._size == 0:
return None
#on prend le début de la skiplist
tower = self._start
#on descend jusqu'au niveau 0 par les sentinelles
while not (tower._belo is None):
tower = tower._belo
#l'élément le plus petit est le suivant de la sentinelle
return tower._next._elem
#retourne l'élément le plus grand de la skiplist
def Max(self):
#si la skiplist est vide, il n'existe pas
if self._size == 0:
return None
#on prend la sentinelle à droite du début de la skiplist
tower = self._start._next
#on descend jusqu'au niveau 0 par les sentinelles de droite
while not (tower._belo is None):
tower = tower._belo
#l'élément le plus grand est le précédent de la sentinelle
return tower._prev._elem
#recherche et retourne un élément, ou son précédent s'il n'existe pas
def SkipSearch(self, element):
#on prend le début de la skiplist
p = self._start
#tant que sur un niveau supérieur à 0
while not (p._belo is None):
#on descend de niveau
p = p._belo
#tant que l'élément suivant est < que l'élément recherché
while element >= p._next._elem:
#on prend l'élément suivant
p = p._next
#s'arrête et retourne l'élément recherché ou son précédent
return p
#augmente la hauteur de la skiplist
def increaseHeight(self):
#on retient les anciennes sentinelles du plus haut niveau
old_sentinel_l = self._start
old_sentinel_r = self._start._next
#on crée deux nouvelles sentinelles pour la nouveau niveau
new_sentinel_l = SkipListNode(self._MIN_VALUE, None, None,
old_sentinel_l, None)
new_sentinel_r = SkipListNode(self._MAX_VALUE, new_sentinel_l, None,
old_sentinel_r, None)
new_sentinel_l._next = new_sentinel_r
#on relie les pointeurs du dessus des vielles sentinelles aux nouvelles
old_sentinel_l._abov = new_sentinel_l
old_sentinel_r._abov = new_sentinel_r
#on augmente la variable qui indique la hauteur de la skiplist
self._height += 1
#on ajuste le début de la skiplist
self._start = new_sentinel_l
#insère un noeud après le noeud p et au-dessus du noeud q
def insertAfterAbove(self, p, q, element):
#p est pour le précédent
#q est pour celui au-dessous
#arguments de SkipListNode : element, prev, next, belo, abov
#abov toujours None car on insère toujours au niveau le plus haut
#le nouveau noeud a p comme précédent, p._next comme suivant,
# q au-dessous et rien au-dessus
newnode = SkipListNode(element, p, p._next, q, None)
#on relie le précédent de l'ancien suivant, next._prev, au nouveau noeud
p._next._prev = newnode
#on relie le suivant du précédent, p._next, au nouveau noeud
p._next = newnode
#s'il y a un noeud en-dessous, q n'est pas à None, on le relie au nouveau noeud
#which is abov it
if not (q is None):
q._abov = newnode
#on retourne le nouveau noeud
return newnode
#insertion d'un nouvel élément
#retourne le noeud du plus haut niveau du nouvel élément s'il n'existait pas
#sinon, le noeud du niveau 0 de celui qui existait
def SkipInsert(self, element):
#on commence par le chercher
p = self.SkipSearch(element)
#on sauve le résultat de la recherche
q = p
#si l'élément existait
if p._elem == element:
#on doit modifier sa valeur à chaque niveau
#imaginez des éléments du type ( clé, valeur )
#on doit ajuster la valeur de tous les éléments de sa tour
while (not p is None):
p._elem = element
p = p._abov
#dans ce cas, on a terminé, on retourne
return q
#comme l'élément n'existe pas, p pointe sur le noeud précédent
#nous sommes au niveau 0, donc belo est None
q = self.insertAfterAbove(p, None, element)
#on a inséré un noeud au niveau 0 pour le nouvel élément
#on doit maintenant monter sa tour en fonction de pile ou face
i = 0
coin_flip = self._coin.flip()
while coin_flip == _FACE:
i += 1 #i indique le niveau courant d'insertion
#si on a atteint le niveau du haut
#on doit ajouter un nouveau niveau, on appelle increaseHeight()
if i >= self._height:
self.increaseHeight()
#on doit ajouter un noeud sur le niveau au-dessus
#on cherche un noeud dans les précédents, débutant à p, qui permet de monter de niveau
while p._abov is None:
#on va voir le précédent
p = p._prev
#p pointe vers un noeud qui en possède un au-dessus, on le suit pour monter
p = p._abov
#q pointe vers le noeud inséré précédemment,
#il correspond au noeud en dessous du noeud à insérer
q = self.insertAfterAbove(p, q, element)
#on relance le jeton
coin_flip = self._coin.flip()
#ici on a terminé la tour de l'élément à insérer
#avant de sortir, on incrémente de 1 la taille de la skiplist
self._size += 1
#on retourne le dernier noeud inséré, celui du plus haut niveau ajouté
return q
#_SkipHeadCut
def decreaseHeight(self):
p = self._start._belo
while (not p._belo is None and p._next._elem == self._MAX_VALUE):
self._start = p
self._height -= 1
p = p._belo
return p
#supprime et retourne un élément, s'il existe
#sinon, retourne None
def SkipRemove(self, element):
#on commence par le chercher
p = self.SkipSearch(element)
#s'il existe
if p._elem == element:
#on retire le noeud de cet élément à chaque niveau
tower = p
while not (tower is None):
#comme la suppression dans une liste chaînée
tower._prev._next = tower._next
tower._next._prev = tower._prev
#on monte de niveau
tower = tower._abov
#on retourne
return p
return None
def run(self):
#modified Framework from PyKinectBodyGame demo (Microsoft)
# -------- Main Program Loop -----------
pygame.mixer.music.load('sounds/Shelter.ogg')
#music from Porter Robinson Soundcloud
pygame.mixer.music.play(-1)
while not self._done:
# --- Main event loop
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
self._done = True # Flag that we are done so we exit this loop
elif event.type == pygame.VIDEORESIZE: # window resized
self._screen = pygame.display.set_mode(
event.dict['size'],
pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.RESIZABLE,
32)
if self._kinect.has_new_color_frame():
frame = self._kinect.get_last_color_frame()
self.draw_color_frame(frame, self._frame_surface)
frame = None
if self.splashScreen == True:
#frame = self._kinect.get_last_color_frame()
#self.draw_color_frame(frame, self._frame_surface)
background = pygame.image.load("images/CreditsToVickyYe.png")
#image editing credit to vicky ye
#original image from upscaletravel.com
self._frame_surface.blit(background, [0, 0])
self._frame_surface.blit(
self.gameoverfont.render("LETS PLAY", True,
(255, 255, 255)),
(self.screen_width // 2 - 800, 50))
self._frame_surface.blit(
self.scorefont.render(
"STEP IN FRONT AND CLAP TO START GAME", True,
(255, 255, 255)), (self.screen_width // 2 - 800, 150))
self.snow.add(Snow())
self.snow.update(self.screen_width, self.screen_height)
self.snow.draw(self._frame_surface)
if self.splashScreen == False:
#Draw Graphics
if float(self.time) == 0:
self.originaltime = time.time()
self.draw_background()
self.getHighScore()
self.draw_path()
#updates path coordinates after drawing it
self.up_path_left = 800 + 4 * self.curve4 + self.ofset + self.curveoffset
self.up_path_right = 1120 + 4 * self.curve4 + self.ofset + self.curveoffset
self.bot_path_left = 200 + self.curve1 + self.ofset + self.curveoffset
self.bot_path_right = 1720 + self.curve1 + self.ofset + self.curveoffset
self.draw_sky()
self.draw_mountains()
self.draw_score()
self.draw_lives()
self.draw_time()
#displays in
if float(self.time) < 5:
self._frame_surface.blit(
self.scorefont.render(
"SQUAT AND COLLECT COINS, STAND TO JUMP OVER OBSTACLES",
True, (0, 0, 0)),
(self.screen_width // 2 - 500, 50))
self._frame_surface.blit(
self.scorefont.render("PUT HANDS ON HEAD TO PAUSE",
True, (0, 0, 0)),
(self.screen_width // 2 - 300, 150))
self._frame_surface.blit(
self.scorefont.render(
"YOU HAVE 3 LIVES BUT IF YOU GO OFF THE PATH YOU LOSE THEM ALL",
True, (0, 0, 0)),
(self.screen_width // 2 - 550, 250))
if 6 > float(self.time) > 5:
self._frame_surface.blit(
self.gameoverfont.render("GOOD LUCK!", True,
(0, 0, 0)),
(self.screen_width // 2 - 250, 300))
self.time = "{0:.2f}".format(time.time() - self.originaltime)
#increase speed as game progresses
for coin in self.coins:
coin.updateVelocity(0, .01)
for rock in self.rocks:
rock.updateVelocity(0, .01)
#changs color of the sky
if self.skyb == 255:
self.colorIncreasing = False
if self.skyb == 220:
self.colorIncreasing = True
if self.colorIncreasing == False:
self.skyb -= .25
self.skyr -= .25
if self.colorIncreasing == True:
self.skyb += .25
self.skyr += .25
#sprites are generated by producing a random number
#if 0 produce sprite
#range of random number indicates frequency
x = random.randint(0, 40)
if x == 0 and len(self.rocks) < 1:
r = Rock(self.up_path_left + 250, self.up_path_right + 50)
self.rocks.add(r)
self.rocks.update(self.screen_width, self.screen_height)
self.rocks.draw(self._frame_surface)
n = random.randint(0, 20)
if n == 0:
c = Coin(self.up_path_left + 150, self.up_path_right)
self.coins.add(c)
#print(self.coins)
#print(n)
self.coins.update(self.screen_width, self.screen_height)
self.coins.draw(self._frame_surface)
self.snow.add(Snow())
self.snow.update(self.screen_width, self.screen_height)
self.snow.draw(self._frame_surface)
z = random.randint(0, 500)
if z == 0:
k = Kosbie(self.up_path_left + 150, self.up_path_right)
self.kosbie.add(k)
self.kosbie.update(self.screen_width, self.screen_height)
self.kosbie.draw(self._frame_surface)
if float(self.time) > 9 and float(
self.time) % 5 < 0.075 and self.isPaused == False:
i = random.randint(0, 4)
self.previouscurve = self.curve
self.curve = self.curvevalues[i]
#print(self.curve)
if abs(self.curve1 - self.curve) > 4 and abs(self.curve4 -
self.curve) > 4:
if self.curve > self.curve1:
if self.curve1 != self.curve:
self.curveIn()
if self.curve < self.curve1:
if self.curve1 != self.curve:
self.curveOut()
#curve offset is the offset from curving
if self.curve == 120:
self.curveoffset += 10
if self.curve == 60:
self.curveoffset += 5
if self.curve == -60:
self.curveoffset -= 5
if self.curve == -120:
self.curveoffset -= 10
#adjust sprite location based on curve
if self.curve == 60 and self.curveoffset != 0:
for coin in self.coins:
coin.updatePosition(4, 0)
for rock in self.rocks:
rock.updatePosition(4, 0)
if self.curve == -60 and self.curveoffset != 0:
for coin in self.coins:
coin.updatePosition(-4, 0)
for rock in self.rocks:
rock.updatePosition(-4, 0)
if self.curve == 120 and self.curveoffset != 0:
for coin in self.coins:
coin.updatePosition(8, 0)
for rock in self.rocks:
rock.updatePosition(8, 0)
if self.curve == -120 and self.curveoffset != 0:
for coin in self.coins:
coin.updatePosition(-8, 0)
for rock in self.rocks:
rock.updatePosition(-8, 0)
self.draw_person()
# Get skeletons
if self._kinect.has_new_body_frame():
self._bodies = self._kinect.get_last_body_frame()
#print(self._bodies)
#print(self._kinect.max_body_count)
# --- draw skeletons to _frame_surface
if self._bodies is not None:
for i in range(0, self._kinect.max_body_count):
#TEST LATER
body = self._bodies.bodies[i]
if (body.is_tracked and isInCircle(
self.left_hand[0], self.left_hand[1], 100,
self.right_hand[0], self.right_hand[1])):
self.splashScreen = False
if not body.is_tracked:
continue
joints = body.joints
# ---convert joint coordinates to color space
joint_points = self._kinect.body_joints_to_color_space(
joints)
if self.splashScreen == True:
self.draw_body(joints, joint_points,
SKELETON_COLORS[i])
#temp for testing purpose
#moving hand logic
#finds colorspace point of each hand
if (joints[PyKinectV2.JointType_HandLeft].TrackingState !=
PyKinectV2.TrackingState_NotTracked):
self.left_hand = (
joint_points[PyKinectV2.JointType_HandLeft].x,
joint_points[PyKinectV2.JointType_HandLeft].y)
# print(self.left_hand)
pass
if (joints[PyKinectV2.JointType_HandRight].TrackingState !=
PyKinectV2.TrackingState_NotTracked):
self.right_hand = (
joint_points[PyKinectV2.JointType_HandRight].x,
joint_points[PyKinectV2.JointType_HandRight].y)
# print("righthand:" + str(self.right_hand))
self.draw_hands(self.left_hand[0], self.left_hand[1],
self.right_hand[0], self.right_hand[1])
for kosbie in self.kosbie:
try:
if (kosbie.rect.collidepoint(self.left_hand)
and self.isJumping == False
and coin.rect.y > 500):
kosbie.kill()
self.score += 10
if self.lives < 3:
self.lives += 1
#self.coinsound.play()
elif (kosbie.rect.collidepoint(self.right_hand)
and self.isJumping == False
and coin.rect.y > 500):
kosbie.kill()
self.score += 10
if self.lives < 3:
self.lives += 1
self.coinsound.play()
except:
pass
for coin in self.coins:
try:
#print(coin.rect)
if (coin.rect.collidepoint(self.left_hand)
and self.isJumping == False
and coin.rect.y > 500):
coin.kill()
self.score += 1
self.coinsound.play()
elif (coin.rect.collidepoint(self.right_hand)
and self.isJumping == False
and coin.rect.y > 500):
coin.kill()
self.score += 1
self.coinsound.play()
except:
pass
if self.score > self.highscore:
self.highscore = self.score
self.saveHighScore(self.highscore)
#jumping logic
#tests if is jumping
if (joints[PyKinectV2.JointType_HipLeft].TrackingState !=
PyKinectV2.TrackingState_NotTracked):
self.prevleftleg = self.left_leg
self.left_leg = joints[
PyKinectV2.JointType_HipLeft].Position.y
#print("leftleg:"+ str(self.left_leg))
if (joints[PyKinectV2.JointType_HipRight].TrackingState !=
PyKinectV2.TrackingState_NotTracked):
self.prevrightleg = self.right_leg
self.right_leg = joints[
PyKinectV2.JointType_HipRight].Position.y
#print("BLAH",self.right_leg)
self.jump -= 10
if self.jump < 0:
self.jump = 0
if self.left_leg > -.5 and self.right_leg > -.5:
#y coordinate of the each hip
#checks to make sure you are not standing up
#print("JUMP MAN")
self.isJumping = True
#else:
# self.isJumping=False
#print(self.isJumping)
if self.isJumping == True and self.isFalling == False:
self.jump += 100
if self.jump > 200:
self.isFalling = True
self.jump = 200
if self.jump == 0:
self.isJumping = False
self.isFalling = False
#tilting logic
if (joints[
PyKinectV2.JointType_SpineShoulder].TrackingState
!= PyKinectV2.TrackingState_NotTracked and
joints[PyKinectV2.JointType_SpineMid].TrackingState
!= PyKinectV2.TrackingState_NotTracked):
self.lowerbody = joints[
PyKinectV2.JointType_SpineMid].Position.x
self.previousbody = self.bodylocation
self.bodylocation = joints[
PyKinectV2.JointType_SpineShoulder].Position.x
if (self.bodylocation -
self.lowerbody) > .025 and self.previousbody > 0:
self.ofset -= 15
if self.tilting < 50:
self.tilting += 10
for coin in self.coins:
coin.updatePosition(-5, 0)
for rock in self.rocks:
rock.updatePosition(-5, 0)
elif (self.bodylocation -
self.lowerbody) < -.025 and self.previousbody < 0:
self.ofset += 15
if self.tilting > -50:
self.tilting -= 10
for coin in self.coins:
coin.updatePosition(5, 0)
for rock in self.rocks:
rock.updatePosition(5, 0)
else:
if self.tilting < 0 and self.tilting != 0:
self.tilting += 10
if self.tilting > 0 and self.tilting != 0:
self.tilting -= 10
for rock in self.rocks:
#print(rock.rect.centery)
#print(abs(rock.rect.centerx-self.skier_x))
try:
#checks if rock is at bottom and if colliding when not jumping
if (rock.rect.centery > 1050
and rock.rect.collidepoint(
self.skier_x, self.skier_y + 100)
and self.isJumping == False):
#self.isGameOver=True
self.loselife = True
rock.kill()
except:
pass
#checks to make sure player is still in path'
#print(200+self.ofset)
#print(self.bot_path_left,self.bot_path_right)
if not self.bot_path_left < self.skier_x < self.bot_path_right:
#self.isGameOver=True
self.loselife = True
if self.loselife == True:
self.lives -= 1
self.loselife = False
if self.lives == 0:
self.isGameOver = True
#tracks
if (joints[PyKinectV2.JointType_Head].TrackingState !=
PyKinectV2.TrackingState_NotTracked):
self.head = (joint_points[PyKinectV2.JointType_Head].x,
joint_points[PyKinectV2.JointType_Head].y)
if (joints[PyKinectV2.JointType_ElbowRight].TrackingState
!= PyKinectV2.TrackingState_NotTracked):
self.elbow = (
joint_points[PyKinectV2.JointType_ElbowRight].x,
joint_points[PyKinectV2.JointType_ElbowRight].y)
#checks if dabbing
#if dabbing switch face of skier
if (isInCircle(self.head[0], self.head[1], 150,
self.elbow[0], self.elbow[1])):
self.isYoungchk *= -1
if (isInCircle(self.head[0], self.head[1], 100,
self.left_hand[0], self.left_hand[1])
and isInCircle(self.head[0], self.head[1], 100,
self.right_hand[0],
self.right_hand[1])):
self.isPaused = True
else:
self.isPaused = False
if self.isPaused == True:
self._frame_surface.fill([255, 255, 255])
background = pygame.image.load("images/doggo.jpg")
#image fromhttp://drivethrutv.com/project/subaru-dogs-skiing/
#background = pygame.transform.scale(background
# , (self.screen_width,self.screen_height));
self._frame_surface.blit(background, [0, 0])
self._frame_surface.blit(
self.otherfont.render("PAUSED", True,
(112, 112, 112)),
(self.screen_width // 2 - 800,
self.screen_height // 2))
self._frame_surface.blit(
self.otherfont.render(
"USE YOUR HANDS TO COLLECT COINS", True,
(112, 112, 112)),
(self.screen_width // 2 - 800,
self.screen_height // 2 + 200))
self._frame_surface.blit(
self.otherfont.render("TILT AND JUMP", True,
(112, 112, 112)),
(self.screen_width // 2 - 800,
self.screen_height // 2 + 300))
self._frame_surface.blit(
self.otherfont.render(
"TO STAY ON PATH AND AVOID OBSTACLES", True,
(112, 112, 112)),
(self.screen_width // 2 - 800,
self.screen_height // 2 + 400))
self.isJumping = True
if self._bodies == None:
self.isPaused = True
#game over conditions
if self.isGameOver == True:
self.applause.play()
self._frame_surface.fill([255, 255, 255])
background = pygame.image.load("images/lmao.jpg")
background = pygame.transform.scale(
background, (self.screen_width, self.screen_height))
self._frame_surface.blit(background, [0, 0])
self._frame_surface.blit(
self.otherfont.render("GAME OVER :(", True, (0, 0, 0)),
(self.screen_width // 2 - 850,
self.screen_height // 2 - 100))
self._frame_surface.blit(
self.otherfont.render("CLAP TO RESTART", True, (0, 0, 0)),
(self.screen_width // 2 - 850,
self.screen_height // 2 + 300))
if self.highscore == self.score:
self._frame_surface.blit(
self.otherfont.render(
"NEW HIGH SCORE: %s" % self.highscore, True,
(0, 0, 0)), (self.screen_width // 2 - 850,
self.screen_height // 2 + 100))
else:
self._frame_surface.blit(
self.otherfont.render(
"HIGH SCORE: %s" % self.highscore, True,
(0, 0, 0)), (self.screen_width // 2 - 850,
self.screen_height // 2 + 100))
for event in pygame.event.get():
#if event.type == pygame.MOUSEBUTTONDOWN:
# self.isJumping=True
# print('JUMPING BOI')
#else:
# self.isJumping=False
if event.type == pygame.KEYUP:
self.__init__()
self.time = 0
if self.isGameOver == True and isInCircle(
self.left_hand[0], self.left_hand[1], 100,
self.right_hand[0], self.right_hand[1]):
self.__init__()
self.time = 0
#copy back buffer surface pixels to the screen, resize it if
#needed and keep aspect ratio
#(screen size may be different from Kinect's color frame size)
h_to_w = (float(self._frame_surface.get_height()) /
self._frame_surface.get_width())
target_height = int(h_to_w * self._screen.get_width())
surface_to_draw = pygame.transform.scale(
self._frame_surface, (self._screen.get_width(), target_height))
self._screen.blit(surface_to_draw, (0, 0))
surface_to_draw = None
pygame.display.update()
# --- Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# --- Limit to 60 frames per second
self._clock.tick(60)
# Close our Kinect sensor, close the window and quit.
self._kinect.close()
pygame.quit()
def min_catch_strategy(coins_name: list):
os.makedirs('logs', exist_ok=True)
log_file = open("logs/MCS_order.log", "a")
print(f'{get_now_time()} 시작가: {get_krw():.2f}')
log_file.write(f'{get_now_time()} 시작가: {get_krw():.2f}\n')
print_order_config(config.items(section="VB_ORDER"))
coin_dict = dict()
for coin_name in coins_name:
coin_dict[coin_name] = Coin(coin_name)
while True:
for i, coin in enumerate(coin_dict.values()):
try:
candles = get_candles('KRW-' + coin.coin_name,
count=2,
minute=UNIT,
candle_type=CANDLE_TYPE)
coin.high_price = max(candles[0]["trade_price"],
coin.high_price)
now = candles[0]['candle_date_time_kst']
if coin.state != State.PASS:
print(
f'{get_now_time()} {coin.coin_name:>6}({set_state_color(coin.state)}{coin.MCS_bought_cnt})| '
f'목표 가: {coin.MCS_buy_price[coin.MCS_bought_cnt] if coin.MCS_bought_cnt < MAX_BOUGHT_CNT else 0:>11.2f}, '
f'현재 가: {candles[0]["trade_price"]:>10},'
f'구매 가: {coin.avg_buy_price:>11.2f}'
f' ({set_dif_color(candles[0]["trade_price"], coin.MCS_buy_price[coin.MCS_bought_cnt] if coin.MCS_bought_cnt < MAX_BOUGHT_CNT else 0)}) '
f' ({set_dif_color(candles[0]["trade_price"], coin.avg_buy_price)}) '
)
# 매도 조건
# 시간 캔들이 바뀐 경우
if coin.check_time != now:
if i == 0:
print(
f'----------------------------------- UPDATE ---------------------------------------'
f'\n{coin.check_time} -> \033[36m{now}\033[0m')
if coin.state in [State.BOUGHT, State.ADDBUY
] or coin.MCS_bought_cnt != 0:
sell_result = coin.sell_coin()
print(
f'\033[104m{get_now_time()} {coin.coin_name:>6}( SELL)| {int(round(get_sell_price(sell_result)))}원\033[0m'
)
log_file.write(
f'{get_now_time()}, {coin.coin_name}, SELL, {int(round(get_sell_price(sell_result)))}\n'
)
coin.state = State.WAIT
coin.max_earnings_ratio = 0
coin.earnings_ratio = 0
coin.check_time = now
coin.variability = candles[1]['high_price'] - candles[1][
'low_price']
coin.high_price = candles[0]["opening_price"]
print(coin.variability, coin.high_price * 0.015)
if coin.variability < coin.high_price * 0.015:
coin.state = State.PASS
coin.avg_buy_price = 0
coin.MCS_bought_cnt = 0
coin.MCS_buy_price = [
candles[0]["opening_price"] -
coin.variability * var * BUY_DIF_RANGE
for var in range(1, MAX_BOUGHT_CNT + 1)
]
print(coin.MCS_buy_price)
if i == len(coin_dict) - 1:
print(
f'---------------------------------------------------------------------------------'
)
else: # 시간이 동일하다면
if coin.MCS_bought_cnt >= MAX_BOUGHT_CNT\
or candles[0]['trade_price'] > coin.MCS_buy_price[coin.MCS_bought_cnt]\
or coin.state == State.PASS:
continue
# 매수
buy_result = coin.buy_coin(price=BUY_AMOUNT)
coin.MCS_bought_cnt += 1
if not buy_result:
continue
print(
f'\033[101m{get_now_time()} {coin.coin_name:>6}( BUY{coin.MCS_bought_cnt})| {coin.bought_amount}원\033[0m'
)
log_file.write(
f'{get_now_time()}, {coin.coin_name}, BUY{coin.MCS_bought_cnt}, {coin.bought_amount}\n'
)
except IndexError as e:
continue