• Explore
• My scripts
• Calculator

from math import pi, asin, sin, cos, sqrt

def fix_angle(a):
  return a * 2 * asin(1) / pi

def col3_2_rgb(c, bits, bgr):
  return c[2*bgr]//2**(8 - bits[0]) + c[1]//2**(8 - bits[1])*2**bits[0] + c[2*(not bgr)]//2**(8-bits[2])*2**(bits[0] + bits[1])
def kc16_draw_line(x1, y1, x2, y2, c):
  draw_line(int(x1), int(y1), int(x2), int(y2), col3_2_rgb(c, [5, 6, 5], 1))
def kc16_fill_rect(x, y, w, h, c):
  draw_rectangle(float(x), float(y), float(w), float(h), col3_2_rgb(c, [5, 6, 5], 1) + filled)
def kc16_fill_ellipse(x, y, rx, ry, c):
  draw_arc(float(x), float(y), float(rx), float(ry), 0, 2*pi, col3_2_rgb(c, [5, 6, 5], 1) + filled)

def get_infos():
  global kc16_draw_line, kc16_fill_rect, kc16_fill_ellipse
  fnop = lambda : None
  screen_w, screen_h, color_bits, poly_has_color, poly_set_pixel, poly_show, poly_draw_line, poly_fill_rect, poly_fill_ellipse, poly_clean_screen, poly_pause, need_clean, need_pause, need_line, need_rect, need_ellipse = 0, 0, [5, 6, 5], 1, fnop, fnop, fnop, fnop, fnop, fnop, fnop, 0, 0, 1, 1, 1
  try:
    if chr(256)==chr(0): # KhiCAS Python compat.
      need_line = 0
      need_clean = 1
      screen_w, screen_h = 320, 222
      def poly_set_pixel(x, y, c):
        set_pixel(x, y, col3_2_rgb(c, [5,6,5], 0))
      poly_draw_line, poly_fill_rect, poly_fill_ellipse = kc16_draw_line, kc16_fill_rect, kc16_fill_ellipse
  except:
    pass
  if not screen_w:
    kc16_draw_line, poly_fill_rect, poly_fill_ellipse = None, None, None
    try: # KhiCAS Micropython
      import graphic
      def poly_draw_line(x1, y1, x2, y2, c):
        graphic.draw_line(int(x1), int(y1), int(x2), int(y2), col3_2_rgb(c, color_bits, 1))
      def poly_fill_rect(x1, y1, x2, y2, c):
        graphic.draw_filled_rectangle(int(x1), int(y1), int(x2), int(y2), c)
      def poly_fill_ellipse(x, y, rx, ry, c):
        graphic.draw_filled_arc(int(x), int(y), int(rx), int(ry), 0, 360, c)
      screen_w, screen_h, poly_set_pixel, need_clean, need_line, need_rect, need_ellipse = 320, 222, graphic.set_pixel, 1, 0, 0, 0
    except:
      pass
  if not screen_w:
    try: # NumWorks
      import kandinsky
      screen_w, screen_h, poly_set_pixel, need_rect = 320, 222, kandinsky.set_pixel, 0
      def poly_fill_rect(x, y, w, h, c):
        kandinsky.fill_rect(int(x), int(y), int(w), int(h), c)
    except:
      pass
  if need_line:
    def poly_draw_line(x1, y1, x2, y2, c):
      m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
      if (x2 - x1) ** 2 < (y2 - y1) ** 2:
        m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
      if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
      for k in range(a2 - a1 + 1):
        a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
        poly_set_pixel((a, b)[m], (b, a)[m], c)

  if need_rect:
    def poly_fill_rect(x, y, w, h, c):
      for k in range(h):
        poly_draw_line(x, y + k, x + w - 1, y + k, c)

  if need_ellipse:
    from math import sqrt
    def poly_fill_ellipse(x, y, rx, ry, c):
      for h in range(-ry, ry+1):
        w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
        x1, x2 = x - w, x + w
        yc = y + h
        poly_draw_line(x1, yc, x2, yc, c)

  if need_clean:
    def poly_clean_screen():
      poly_fill_rect(0, 0, screen_w, screen_h, [255, 255, 255])

  return screen_w, screen_h, poly_has_color, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_fill_ellipse, poly_clean_screen, fnop

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]

def plan():
  modifier_vol(-1, 0, 5)
  modifier_vol(1, 0, 8)
  modifier_vol(-0.89, 0.1, 6)
  modifier_vol(0, 0.1, 5)
  modifier_vol(1, 0.1, 8)

#voler_selon(plan)