ATTENTION: CE PROGRAMME EXIGE TOUTE LA MEMOIRE DE LA CALCULATRICE (donc supprimer tous les autres programmes python présents avant de l’injecter).

Expérience sur le raycasting: on projette des rayons de lumière dans un espace 2D, et on affiche les “murs” en fonction de la distance à laquelle les rayons touchent un mur (ou non). Pour se déplacer vers l’avant, tapez 5 puis EXE. Pour tourner à droite ou à gauche tapez 4 ou 6, puis EXE. Au début de la méthode paly sont contenues différentes variables: -x,y sont pour la position initiale de l’observateur -direction est l’orientation initiale de l’observateur (en radians –allant de -pi/2 à pi/2–) -step_l est la distance parcourue par un pas -fov est le champ de vision (allant de 0 à 2*pi) -n_rays est le nombre de rayons incidents -ray_steps est la vitesse de propagation d’un rayon -ray_len est le nombre d’unités de vitesse parcourues par un rayon

import kandinsky as k
from math import *
global rays
rays=[]

def fill(a,b,c,d,e):
  k.fill_rect(a,b,c,d,e)

def level():
  fill(0,111,320,111,(0,0,0))
  fill(2,113,316,107,(255,255,255))
  fill(40,113,5,40,(0,0,0))
  fill(80,222-50,40,50,(0,0,0))
  fill(150,141,50,10,(0,0,0))
  fill(200,113,3,50,(0,0,0))
  fill(280,150,360-280,50,(0,0,0))

class ray():
  def __init__(self,x,y,theta,ray_steps,ray_len):
    self.theta=theta
    self.x=x
    self.y=y
    self.ray_steps=ray_steps
    self.ray_len=ray_len
  def project(self):
    self.distance=0
    self.dx=(self.ray_steps)*cos(self.theta)
    self.dy=(self.ray_steps)*sin(self.theta)
    while k.get_pixel(int(self.x+self.dx),int(self.y+self.dy))!=(0,0,0) and self.y>111 and self.distance<self.ray_len:
      fill(int(self.x),int(self.y),1,1,(0,255,0))
      self.x+=self.dx
      self.y+=self.dy
      self.distance+=1

def size_estimator(d):
  return (abs(d-26)-d+31) 

def cast(x,y,direction,fov,n_rays,ray_steps,ray_len):
  for loop in range(n_rays):
    theta=(2*(loop/n_rays)-1)*fov+direction
    rays[loop]=(ray(x,y,theta,ray_steps,ray_len))
    rays[loop].project()

def render():
  fill(0,0,320,111,(255,255,255))
  for loop in range(len(rays)):
    fill(int(loop*320/40),int(55-size_estimator(rays[loop].distance)),int(320/40),int(2*size_estimator(rays[loop].distance)),(0,int(4*size_estimator(rays[loop].distance)),0))
  
  
def play():
  x=60
  y=151
  direction=0
  step_l=15
  fov=pi/4
  n_rays=50
  ray_steps=3
  ray_len=33
  for loop in range(n_rays):
    rays.append(0)
  level()
  cast(x,y,direction,fov,n_rays,ray_steps,ray_len)
  fill(int(x-2),int(y-2),5,5,(0,219,69))
  render()
  while 1:
    dx=step_l*cos(direction)
    dy=step_l*sin(direction)
    ko=input()
    level()
    if ko=="5":
      if k.get_pixel(int(x+dx),int(y+dy))==(248,252,248):
        x+=dx
        y+=dy
    if ko=="4":
      direction+=0.5
    if ko=="6":
      direction-=0.5
    cast(x,y,direction,fov,n_rays,ray_steps,ray_len)
    fill(int(x-2),int(y-2),5,5,(0,219,69))
    render()
play()