def enterObstacleAvoidanceState(self):
     self.log('Entering ObstacleAvoidanceState')
     self.ikEngine.travelX = 0
     self.turnTimeoutTime = pyb.millis() + FRONT_OBSTACLE_TURN_TIMEOUT
     if (self.leftRangeDistance < SIDE_SENSOR_CLEAR_OBSTACLE) & (
         self.rightRangeDistance < SIDE_SENSOR_CLEAR_OBSTACLE):
         # stuff on both sides, pick a direction at random to turn
         if pyb.rng() & 1 == 0:
             self.log('Obstacles on both sides, turning right')
             self.ikEngine.travelRotZ = -FRONT_OBSTACLE_TURN_SPEED
         else:
             self.log('Obstacles on both sides, turning left')
             self.ikEngine.travelRotZ = FRONT_OBSTACLE_TURN_SPEED
     elif self.leftRangeDistance < SIDE_SENSOR_CLEAR_OBSTACLE:
         self.log('Obstacle on left side, turning right')
         self.ikEngine.travelRotZ = -FRONT_OBSTACLE_TURN_SPEED
     elif self.rightRangeDistance < SIDE_SENSOR_CLEAR_OBSTACLE:
         self.log('Obstacle on right side, turning left')
         self.ikEngine.travelRotZ = FRONT_OBSTACLE_TURN_SPEED
     else:  # nothing on either side, so pick a side at random
         if pyb.rng() & 1 == 0:
             self.log('Only front obstacle, turning right')
             self.ikEngine.travelRotZ = -FRONT_OBSTACLE_TURN_SPEED
         else:
             self.log('Only front obstacle, turning left')
             self.ikEngine.travelRotZ = FRONT_OBSTACLE_TURN_SPEED

 def addbomb( self ) :
   x = int(randval(self.ds[0]))
   y = int(randval(self.ds[1]))
   rad = randval(20) + 5
   r = pyb.rng() & 0xFF
   g = pyb.rng() & 0xFF
   b = pyb.rng() & 0xFF
   spd = randval(30.0) + 1.0
   clr = self.display.color(r,g,b)
   self.bombs.insert(0, bomb((x, y), rad, clr, spd))

 def randomise(self):
     array = ptr8(self._array)
     idx = int(self._size_elements)
     while idx:
         val = int(pyb.rng()) & 0xff
         array[idx] = val
         idx -= 1

 def perk(self, delay, color, start=None):
     #print("perk(%d, %r, %r)" % (delay, color, start))
     stoichiometric = self.stoichiometric
     i = None
     while True:
         if i is None:
             if start is None:
                 i = self.top_i
             else:
                 i = start
         self.add_color_to(i, color)
         yield from self.show_for(delay)
         if self.at_mid(i):
             new_color = yield from self.react_at(i)
             if new_color is None:
                 return
             else:
                 color = new_color
         prev_i = i
         i = self.down(i, rng()&1)
         self.sub_color_from(prev_i, color)
         self.leds_need_sync = True
         if i is None:
             return color
         if self.perk_quit:
             break
     self.perk_quit -= 1

	def seed():
		for x in range(0, width-1):
			for y in range(0, height-1):
				if pyb.rng() % 2 == 1:
					grid[x][y] = 1
				else:
					grid[x][y] = 0

def tick():
	global wheelColour, ledcount, sequence, ledpin

	pin = pyb.Pin(ledpin)
	neo = pyb.Neopix(pin)

	leds = [0x000000] * ledcount

	if (sequence == "rainbow"):
		wheelColour = (wheelColour + 8) & 255
		for ledNumber in range(0, ledcount):
			pos = ((ledNumber*8)+wheelColour)
			pos = pos & 255
			leds[ledNumber] = Wheel(pos).get_neo()
	elif (sequence == "matrix"):
		for ledNumber in range(0, ledcount):
			led_green = (pyb.rng() & 255)
			led_colour = Colour(0, led_green, 0)
			if led_green < 230:
				led_colour.set_g(int(led_green / 8))
			if led_green > 253:
				led_colour.set_hex('#ffffff')
			leds[ledNumber] = led_colour.get_neo()
	elif (sequence == "colour"):
		colour = database.database_get("led-colour", "#ffffff")
		tmp_colour = Colour()
		tmp_colour.set_hex(colour)
		leds = [tmp_colour.get_neo()] * ledcount
	neo.display(leds)

def list_shuffle(list):
    for i, item in enumerate(list):
        list[i] = (pyb.rng(), item)
    list.sort()
    for i, item in enumerate(list):
        list[i] = item[1]
    return list

def testpixel( display ) :
  print('testing pixels')
  displaysize = display.size()
  r = 255
  x = -10
  g = 0
  b = 0
  for y in range(-10, displaysize[1] + 10) :
      display.pixel((x, y), pyb.TFT.color(r, g, b))
      x += 1
      g += 2
      b += 1
  for i in range(100):
    x = pyb.rng() % displaysize[0]
    y = pyb.rng() % displaysize[1]
    display.pixel((x,y), randcolor())
  pyb.delay(2000)

def gen_uuid():
    """
    :return uuid of a message 32 random hexadecimal chars
    """
    res = ''
    for i in range(0, 32):
        res += hex(pyb.rng() % 16)[2:].upper()
    return res

def nick_screen(container_handle):
    if not container_handle:
        container_handle = ugfx.Container(0, 0, 320, 240)
    container_handle.area(0, 0, 320, 240, ugfx.html_color(pyb.rng()%0xffffff))
    ugfx.display_image(0, 0, "apps/sponsors/splash3.gif")

    container_handle.show()
    return container_handle

def spawn_enemy():
    if level == 1:
        spawn_quadcopter()
    else:
        if pyb.rng() % 5 == 0:
            spawn_hab()
        else:
            spawn_quadcopter()

def spawn_hab():
    if len(quadcopters) > level:
        print("Too many copters! Call the CAA")
        #global tmc_count
        #tmc_count += 1
        return
    quadcopter = HAB(pyb.rng()%300, 180, speed=1)
    quadcopters.append(quadcopter)

def get_new_game_state(w, h):
    angle = pyb.rng() % MAX_ANGLE + 360 - MAX_ANGLE
    return {'player': {'x': 0, 'y': 0},
            'ai': {'x': w - 2,
                   'y': h - 15},
            'ball': {'x': 5,
                     'y': 5,
                     'velocity': get_velocity(angle)},
            'score': 0}

def spawn_quadcopter():
    if len(quadcopters) > level:
        print("Too many copters! Call the CAA")
        global tmc_count
        tmc_count += 1
        return
    right = pyb.rng() % 2
    if right:
        x = 0
        direction = '+'
    else:
        x = 320
        direction = '-'
    speed = (pyb.rng() % (level))
    if speed == 0:
        speed = 1
    quadcopter = Quadcopter(x, pyb.rng() % 160, direction=direction, speed=speed)
    quadcopters.append(quadcopter)

def generate_board():
    """
    Returns random board.
    """
    board = set()
    for x in range(8):
        for y in range(8):
            if pyb.rng() % 2 == 0:
                board.add((x, y))
    return board

 def minnow(t):
     minnows = self.minnows
     fut = Future()
     minnows.add(fut)
     while True:
         try:
             yield from wait_for(fut, pyb.rng() % t)
             return
         except TimeoutError:
             if len(minnows) < 32:
                 yield minnow(t)  # Create another

 async def testmeter(self, meter):
     oldvalue = 0
     await asyncio.sleep(0)
     while True:
         val = pyb.rng() / 2**30
         steps = 20
         delta = (val - oldvalue) / steps
         for _ in range(steps):
             oldvalue += delta
             meter.value(oldvalue)
             await asyncio.sleep_ms(100)

 def bingo(self):
     stars = list(range(7, 63, 7))
     p = self.percolator
     lattice = p.lattice
     rand.shuffle(stars)
     for i in stars:
         yield from sleep(200)
         color = tuple(lattice[i])
         p.set_color_of(i, (0,0,0))
         i = self.percolator.down(i, rng()&1)
         yield self.perk_and_roll(100, color, i)

def orc_kicking(strength, orc, hp):
	ugfx.area(190,30,300,180, ugfx.BLACK)
	damage_orc = (pyb.rng()%6)
	ugfx.text(190, 30, "You kick the orc!", ugfx.WHITE)
	ugfx.text(190, 50, "The orc takes", ugfx.WHITE)
	ugfx.text(190, 70, str(damage_orc)+" damage.", ugfx.WHITE)
	orc = orc-damage_orc
	tone(155.563,250,30)
	pyb.delay(1000)
	damage = (pyb.rng()%strength)
	ugfx.text(190, 100, "The orc kicks you!", ugfx.WHITE)
	ugfx.text(190, 120, "You take "+str(damage)+" damage.", ugfx.WHITE)
	hp = hp-damage
	tone(174.614,250,30)
	
	ugfx.text(190, 150, "A: Kick again", ugfx.RED)
	ugfx.text(190, 170, "B: Run away", ugfx.RED)
	
	ugfx.area(30,200,180,250, ugfx.BLACK)
	ugfx.text(30, 200, "HP: "+str(hp), ugfx.BLUE)
	return orc,hp

 def fib(n, fut):
     yield from sleep(pyb.rng() % n)
     if n <= 2:
         fut.set_result(1)
     else:
         f1 = Future()
         f2 = Future()
         yield fib(n - 1, f1)
         yield fib(n - 2, f2)
         v1 = yield from wait_for(f1)
         v2 = yield from wait_for(f2)
         fut.set_result(v1 + v2)
         return (v1 + v2)