#cas
from math import pi, sin, cos, sqrt
from polycal2 import *

def rnd():
  global s
  rnd_max = 0x7fff
  s = (s * 214013 + 2531011) % 4294967296
  return ((s // (2*rnd_max + 1)) & rnd_max) / rnd_max

def hmap(t):
  frq, pha, hm, amp = [ 1, 3, 15, 21, 39, 51, 97, 145 ], [], [], []
  for i in range(8):
    amp.append((rnd() + 1) * (cave_h * 27) / 200 / 1.2**i)
  for k in frq:
    pha.append(pi * rnd())
  for x in range(cave_w):
    hm.append(int(sum([amp[i] * (1 + sin(fix_angle(frq[i]*x/cave_w + pha[i]))) / 2 for i in range(len(amp))])))
  return [ h - min(hm) + t for h in hm ]

cave_w, cave_h, s = 128, 64, 0xdeadbeef
fl, cv = hmap(2), hmap(8)

screen_w, screen_h, poly_has_color, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_fill_ellipse, poly_clean_screen, poly_show_screen = get_infos()
zx, zy = (screen_w - 1) / (cave_w - 1), (screen_h - 1) / (cave_h - 1)
get_infos, poly_set_pixel, hmap, rnd = None, None, None, None

def interpol1(yi, yf, dx):
  return yi + dx*(yf - yi)

def interpol_list(lst, i):
  i0 = int(i)
  v = lst[i0]
  if i > i0 and i < len(lst) - 1:
    v = interpol1(v, lst[i0 + 1], i - i0)
  return v

def test_collision(x, y):
  f = cave_h - interpol_list(fl, x)
  return y >= f or y <= f-interpol_list(cv, x)

def test_collision_rect(x, y, dx, dy):
  x1, x2, y1, y2 = max(0, x - dx), min(cave_w - 1, x + dx), y - dy, y + dy
  return test_collision(x1, y1) + test_collision(x2, y1) + test_collision(x1, y2) + test_collision(x2, y2)

def test_balloon(x, y, rx, ry, d_vert):
  rmax, r2, k, collisions = [rx, ry][d_vert], [ry, rx][d_vert], -1, 0
  while k < rmax:
    k = min(k + 1, rmax)
    k2 = sqrt(max(0, r2*r2*(1 - k*k/rmax/rmax)))
    collisions += test_collision_rect(x, y, [k, k2][d_vert], [k2, k][d_vert])
  return collisions

def rxy(a):
  if a%2 == 1:
    rx, ry = 0, 1-2*(a%4 == 3)
  else:
    a = fix_angle(a * pi/2)
    rx, ry = abs(cos(a)), abs(sin(a))
  return 1 + abs(rx), 1 + abs(ry)

colors = ([0, 0, 0], [255, 255, 255], [0, 0, 255], [255, 0, 0], [159, 159, 159])

def modifier_vol(ay, da, dt):
  global state
  if ay or da:
    state[4] += 10
  x, y, a = state[0:3]
  while state[0] < cave_w - 1 and dt:
    state[0] += 1
    state[2] = max(0, min(1, a + da))
    state[3] -= ay
    state[1] = max(0, min(cave_h - 1, state[1] + state[3]))
    dt = max(0, dt - 1)  
    da, dapi, dx = abs(state[2] - a), abs(state[2] - .5), 1
    state[4] += 3*(da > 0)*(1 + da) + 2*(dapi > 0)*(1 + dapi)
    xc, yc, dx = x, y, 1
    rx, ry = rxy(state[2])
    if state[1] != y:
      dx = min(1 / abs(state[1] - y), 1)
    collisions = test_balloon(state[0], state[1], rx, ry, 0) + test_balloon(state[0], state[1], rx, ry, 1)
    if collisions:
      state[4] += 7 * (1 + collisions)
    while xc < state[0]:
      xc += dx/zx
      yc = interpol1(y, state[1], xc - x)
      rx, ry = rxy(interpol1(a, state[2], state[2] - a))
      poly_fill_ellipse(xc * zx, yc * zy, rx * zx, ry * zy, colors[2*poly_has_color + (collisions > 0)])
    x, y, a = state[0], state[1], state[2]

def voler_selon(f):
  global state, fl, cv
  state = [0, 12, .5, 0,0]
  poly_fill_rect(0, 0, screen_w, screen_h, colors[4])
  for x in range(cave_w):
    f1, dx = cave_h - fl[x], 0
    c1 = f1 - cv[x]
    while dx < zx:
      f2 = cave_h - interpol_list(fl, x + dx/zx)
      c2 = f2 - interpol_list(cv, x + dx/zx)
      poly_draw_line(x*zx + dx, c2 * zy, x*zx + dx, f2 * zy, colors[1])
      dx += 1
    if poly_has_color:
      poly_draw_line(x * zx, c1 * zy, (x + 1) * zx, c2 * zy, colors[0])
      poly_draw_line(x * zx, f1 * zy, (x + 1) * zx, f2 * zy, colors[0])
  f()
  if state[0] < cave_w - 1:
    modifier_vol(0, 0, cave_w - 1 - state[0])
  poly_show_screen()
  print('Consommation : ' + str(state[4]))
  print('Bravo, tu es passe-e.')
  print('Pour jouer et gagner,')
  print('envoie ton script a')
  print('info@tiplanet.org.')
  return state[4]