diff -ruN -x '*.png' a/main.py b/main.py
--- a/main.py	1969-12-31 21:00:00.000000000 -0300
+++ b/main.py	2026-11-04 23:19:11.717535874 -0300
@@ -0,0 +1,11 @@
+import pygame
+import asyncio
+import os
+import sys
+
+mainpath = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(mainpath)
+sys.path.append(os.path.join(mainpath, "src"))
+import wd_main
+
+asyncio.run(wd_main.main(mainpath))
diff -ruN -x '*.png' a/run_game.py b/run_game.py
--- a/run_game.py	2026-11-04 23:15:17.491709757 -0300
+++ b/run_game.py	1969-12-31 21:00:00.000000000 -0300
@@ -1,12 +0,0 @@
-#!/usr/bin/python
-
-"""
-run_game.py - Used to run game
-"""
-
-import sys, os
-mainpath = os.path.abspath(os.path.dirname(sys.argv[0]))
-sys.path.append(mainpath)
-sys.path.append(os.path.join(mainpath,"src"))
-import main
-main.main(mainpath)
diff -ruN -x '*.png' a/src/common.py b/src/common.py
--- a/src/common.py	2026-11-04 23:15:17.539950321 -0300
+++ b/src/common.py	2026-11-04 23:19:11.670746051 -0300
@@ -27,14 +27,14 @@
             self.y = focus[1] - self.stickyness*self.h_view/2
         elif (focus[1] - self.y) < -self.stickyness*self.h_view/2:
             self.y = focus[1] + self.stickyness*self.h_view/2
-        if self.x < self.w_view/2:
-            self.x = self.w_view/2
-        elif self.x > (self.xlim-self.w_view/2):
-            self.x = self.xlim-self.w_view/2
-        if self.y < self.h_view/2:
-            self.y = self.h_view/2
-        elif self.y > (self.ylim-self.h_view/2):
-            self.y = self.ylim-self.h_view/2
+        if self.x < self.w_view//2:
+            self.x = self.w_view//2
+        elif self.x > (self.xlim-self.w_view//2):
+            self.x = self.xlim-self.w_view//2
+        if self.y < self.h_view//2:
+            self.y = self.h_view//2
+        elif self.y > (self.ylim-self.h_view//2):
+            self.y = self.ylim-self.h_view//2
         self.x = int(self.x)
         self.y = int(self.y)
 
@@ -61,7 +61,7 @@
                 if self.smooth:
                     self.alpha = 255*(1.0-(self.ticks_elapsed/float(self.ticks)))
                 else:
-                    self.alpha = 255*(1.0-((5*(self.ticks_elapsed/5))/float(self.ticks)))
+                    self.alpha = 255*(1.0-((5*(self.ticks_elapsed//5))/float(self.ticks)))
         elif self.direction == 'out' and not self.finished_out:
             self.ticks_elapsed += 1
             if self.ticks_elapsed > self.ticks:
@@ -70,7 +70,7 @@
                 if self.smooth:
                     self.alpha = 255*(self.ticks_elapsed/float(self.ticks))
                 else:
-                    self.alpha = 255*((5*(self.ticks_elapsed/5))/float(self.ticks))
+                    self.alpha = 255*((5*(self.ticks_elapsed//5))/float(self.ticks))
                 if self.musicfade:
                     pygame.mixer.music.set_volume(0.5*(1.0 - (self.ticks_elapsed/float(self.ticks))))
     
diff -ruN -x '*.png' a/src/cutscenes.py b/src/cutscenes.py
--- a/src/cutscenes.py	2026-11-04 23:15:17.541355938 -0300
+++ b/src/cutscenes.py	2026-11-04 23:19:11.676338395 -0300
@@ -36,8 +36,8 @@
         pygame.mixer.music.play(-1)
         
         # top-level menu buttons
-        pos_h1 = (self.window_size[0]/2)-(resources.titlescreen_surfs['continue_red'].get_width()/2)
-        pos_h2 = (self.window_size[0]/2)-(resources.titlescreen_surfs['newgame_red'].get_width()/2)
+        pos_h1 = (self.window_size[0]//2)-(resources.titlescreen_surfs['continue_red'].get_width()//2)
+        pos_h2 = (self.window_size[0]//2)-(resources.titlescreen_surfs['newgame_red'].get_width()//2)
         if os.path.isfile(self.savepath):
             self.button_continue = MenuButton((pos_h1,66),resources.titlescreen_surfs['continue_red'],resources.titlescreen_surfs['continue_white'],self.continue_game_now)
             self.button_newgame = MenuButton((pos_h2,96),resources.titlescreen_surfs['newgame_red'],resources.titlescreen_surfs['newgame_white'],self.start_game_now)
@@ -180,13 +180,13 @@
             render_animation(screen)
             return
         surf = resources.cutscenesurfs[bgdata]
-        pos = ((self.window_size[0]/2)-(surf.get_width()/2), (self.window_size[1]/2)-(surf.get_height()/2))
+        pos = ((self.window_size[0]//2)-(surf.get_width()//2), (self.window_size[1]//2)-(surf.get_height()//2))
         screen.blit(surf, pos)
     
     def render_text(self, screen):
         textdata = self.sequence[self.step][1][self.textstep]
         surf = resources.cutscenesurfs[textdata]
-        pos = ((self.window_size[0]/2)-(surf.get_width()/2), (self.window_size[1]/2)-(surf.get_height()/2))
+        pos = ((self.window_size[0]//2)-(surf.get_width()//2), (self.window_size[1]//2)-(surf.get_height()//2))
         surf.set_alpha(255-self.fade_text.alpha)
         screen.blit(surf, pos)
     
diff -ruN -x '*.png' a/src/game.py b/src/game.py
--- a/src/game.py	2026-11-04 23:15:17.538595245 -0300
+++ b/src/game.py	2026-11-04 23:19:11.668438856 -0300
@@ -257,10 +257,10 @@
         self.background.blit(backfade, (0,0))
         
         # top-level menu buttons
-        self.pos_h = (self.window_size[0]/2)-((resources.pausescreen_surfs['bg'].get_width()+resources.pausescreen_surfs['help'].get_width()+40)/2)
+        self.pos_h = (self.window_size[0]//2)-((resources.pausescreen_surfs['bg'].get_width()+resources.pausescreen_surfs['help'].get_width()+40)//2)
         self.pos_h2 = self.pos_h + resources.pausescreen_surfs['bg'].get_width() + 40
-        self.pos_v = (self.window_size[1]/2)-(resources.pausescreen_surfs['bg'].get_height()/2)
-        self.pos_v2 = (self.window_size[1]/2)-(resources.pausescreen_surfs['help'].get_height()/2)
+        self.pos_v = (self.window_size[1]//2)-(resources.pausescreen_surfs['bg'].get_height()//2)
+        self.pos_v2 = (self.window_size[1]//2)-(resources.pausescreen_surfs['help'].get_height()//2)
         self.button_resume = MenuButton((self.pos_h,self.pos_v+26),resources.pausescreen_surfs['resume_on'],resources.pausescreen_surfs['resume_off'],self.resume_game_now)
         self.button_reset = MenuButton((self.pos_h,self.pos_v+40),resources.pausescreen_surfs['reset_on'],resources.pausescreen_surfs['reset_off'],self.reset_game_now)
         self.button_quit = MenuButton((self.pos_h,self.pos_v+54),resources.pausescreen_surfs['quit_on'],resources.pausescreen_surfs['quit_off'],self.quit_game_now)
diff -ruN -x '*.png' a/src/gamedirector.py b/src/gamedirector.py
--- a/src/gamedirector.py	2026-11-04 23:15:17.536644798 -0300
+++ b/src/gamedirector.py	2026-11-04 23:19:11.716937419 -0300
@@ -4,6 +4,8 @@
 gamedirector.py - classes for running the game using a director/scene structure
 """
 
+import asyncio
+import time
 import pygame
 from pygame.locals import *
 
@@ -20,9 +22,14 @@
         self.frame = 0
         self.timesincestart = 0
     
-    def loop(self):
+    async def loop(self):
+        last = time.time()
         while not self.quit_flag:
-            self.time = self.clock.tick(self.fps)
+            # frame limiter for the browser: the page needs control back every frame
+            await asyncio.sleep(max(0.0, 1.0 / self.fps - (time.time() - last)))
+            now = time.time()
+            self.time = max(1, int((now - last) * 1000))
+            last = now
             self.framerate = 1000.0/self.time
             self.frame = self.frame + 1
             self.timesincestart = self.timesincestart + self.time
@@ -49,8 +56,8 @@
             b_movie = False
             movie_framerate = 15
             outnumoffset = 0
-            if b_movie and self.frame % (self.fps/movie_framerate) == 0:
-                pygame.image.save(self.screen,"screens/screen_%04d.jpg"%(self.frame/(self.fps/movie_framerate) + outnumoffset))
+            if b_movie and self.frame % (self.fps//movie_framerate) == 0:
+                pygame.image.save(self.screen,"screens/screen_%04d.jpg"%(self.frame//(self.fps//movie_framerate) + outnumoffset))
                 #pygame.image.save(self.screen,"screens/screen_%04d.png"%(self.frame/(self.fps/movie_framerate) + outnumoffset))
             
             pygame.display.flip()
@@ -60,7 +67,7 @@
     
     def change_scene(self, scenename, switchtoargs):
         if scenename is None:
-            self.quit()
+            pass  # the web page has nowhere to quit to
         else:
             self.scene = self.scenelist[scenename]
             self.scene.on_switchto(switchtoargs)
diff -ruN -x '*.png' a/src/killerbat.py b/src/killerbat.py
--- a/src/killerbat.py	2026-11-04 23:15:17.539443574 -0300
+++ b/src/killerbat.py	2026-11-04 23:19:11.669628557 -0300
@@ -56,7 +56,7 @@
     def kill(self):
         if self.status == "alive":
             self.status = "dying"
-            current_tile = (self.x/16)+self.h_group.h_tiledlayers.map_size[0]*(self.y/16)
+            current_tile = (self.x//16)+self.h_group.h_tiledlayers.map_size[0]*(self.y//16)
             self.h_group.h_tiledlayers.RemoveObj(current_tile,self.id)
             self.frametype = 'death'
             self.frame = 0
@@ -64,7 +64,7 @@
     
     def update_alive(self):
         
-        init_tile = self.h_group.h_tiledlayers.map_size[0]*(self.y/16)+(self.x/16)
+        init_tile = self.h_group.h_tiledlayers.map_size[0]*(self.y//16)+(self.x//16)
         
         # monster behaviour
         dist2p = pow(self.x-self.h_group.h_player.x,2) + pow(self.y-self.h_group.h_player.y,2)
@@ -100,7 +100,7 @@
         # Handle all collisions off solid objects
         (self.x,self.y) = self.h_group.h_tiledlayers.HandleObjectWallCollision((self.x,self.y),(10,10),(self.vx,self.vy))
         
-        final_tile = self.h_group.h_tiledlayers.map_size[0]*(self.y/16)+(self.x/16)
+        final_tile = self.h_group.h_tiledlayers.map_size[0]*(self.y//16)+(self.x//16)
         if not init_tile == final_tile:
             self.h_group.h_tiledlayers.UpdateObj(init_tile,final_tile,self.id)
         
@@ -130,9 +130,9 @@
             src_coords = resources.bat_spritesheet_coords[self.heading][resources.bat_spriteseq[self.frametype][self.frame]]
             self.sprite.source_rect.x = src_coords[0]
             self.sprite.source_rect.y = src_coords[1]
-            (camerax,cameray) = (self.h_group.h_camera.x-self.h_group.h_camera.w_view/2,self.h_group.h_camera.y-self.h_group.h_camera.h_view/2)
-            self.sprite.rect.x = int(self.x-self.size[0]/2-camerax)
-            self.sprite.rect.y = int(self.y-self.size[1]/2-cameray)
+            (camerax,cameray) = (self.h_group.h_camera.x-self.h_group.h_camera.w_view//2,self.h_group.h_camera.y-self.h_group.h_camera.h_view//2)
+            self.sprite.rect.x = int(self.x-self.size[0]//2-camerax)
+            self.sprite.rect.y = int(self.y-self.size[1]//2-cameray)
         else:
             self.sprite.rect.x = -10000
             self.sprite.rect.y = -10000
@@ -147,7 +147,7 @@
     
     def AddBat(self,tile):
         x = self.h_tiledlayers.tilesize*(tile%self.h_tiledlayers.map_size[0])
-        y = self.h_tiledlayers.tilesize*(tile/self.h_tiledlayers.map_size[0])
+        y = self.h_tiledlayers.tilesize*(tile//self.h_tiledlayers.map_size[0])
         id = len(self.bats)+1000
         self.bats.append(KillerBat(x,y,id,self))
         self.sprite_group.add(self.bats[-1].sprite)
diff -ruN -x '*.png' a/src/main.py b/src/main.py
--- a/src/main.py	2026-11-04 23:15:17.542467557 -0300
+++ b/src/main.py	1969-12-31 21:00:00.000000000 -0300
@@ -1,90 +0,0 @@
-#!/usr/bin/python
-
-"""
-main.py - Main entry point for game
-"""
-
-import os
-import pygame
-from pygame.locals import *
-from gamedirector import *
-
-import resources
-import game
-import cutscenes
-
-# Start
-def main(mainpath):
-
-    # Initialise pygame
-    pygame.init()
-    pygame.mixer.init()
-    pygame.mouse.set_visible(False)
-    
-    # start up director
-    framerate = 30
-    #screen_res = (480,320)
-    screen_res = (320,240)
-    #screen_res = (192,128)
-    window_title = "Game"
-    dir = GameDirector(window_title, screen_res, framerate)
-    
-    # Load resources
-    resources.init(mainpath,screen_res)
-    
-    # Title Screen
-    titlescene = cutscenes.TitleScreen(dir, screen_res)
-    titlescene.savepath = os.path.join(mainpath,'data','saved_progress.txt')
-    dir.addscene('titlescene', titlescene)
-    
-    # Cutscens
-    logocutscene = cutscenes.CutScene(dir, screen_res)
-    dir.addscene('logocutscene', logocutscene)
-    
-    storycutscene = cutscenes.CutScene(dir, screen_res)
-    dir.addscene('storycutscene', storycutscene)
-    
-    gotscrollscene = cutscenes.GotScroll(dir, screen_res)
-    dir.addscene('gotscroll', gotscrollscene)
-    
-    wingamescene = cutscenes.CutScene(dir, screen_res)
-    dir.addscene('wingamescene', wingamescene)
-    
-    # Load game scenes
-    maingame = game.MainGame(dir, screen_res)
-    maingame.progress_data.savepath = os.path.join(mainpath,'data','saved_progress.txt')
-    titlescene.h_progress_data = maingame.progress_data
-    dir.addscene('maingame', maingame)
-    deathscene = game.Death(dir, screen_res)
-    dir.addscene('death', deathscene)
-    pausescene = game.PauseScreen(dir, screen_res)
-    dir.addscene('pausescene', pausescene)
-    maingame.h_pausescene = pausescene
-    
-    # start up director
-    #dir.change_scene('maingame', [True,"level_computerroom",-1])
-    #dir.change_scene('maingame', [True,"level_dragonroom",-1])
-    
-    #dir.change_scene('maingame', [True,"level_basicmechanisms",-1])
-    #dir.change_scene('maingame', [True,"level_basiclava",-1])
-    #dir.change_scene('maingame', [True,"level_theroundabout",-1])
-    #dir.change_scene('maingame', [True,"level_basicelectric",-1])
-    #dir.change_scene('maingame', [True,"level_thelift",-1])
-    
-    #dir.change_scene('maingame', [True,"level_getscroll_blue",-1])
-    #dir.change_scene('maingame', [True,"level_getscroll_green",-1])
-    #dir.change_scene('maingame', [True,"level_getscroll_red",-1])
-    
-    #dir.change_scene('titlescene', [])
-    dir.change_scene('logocutscene', resources.logocutscene_data)
-    #dir.change_scene('storycutscene', resources.storycutscene_data)
-    #dir.change_scene('wingamescene', resources.wingamescene_data)
-    
-    #dir.change_scene('gotscroll', ["scroll_red"])
-    dir.loop()
-    
-    # exiting, record framerate
-    #fp = open(os.path.join(mainpath,'framerate.txt'),"w")
-    #fp.write("%f\n"%(maingame.avgframerate))
-    #fp.close()
-
diff -ruN -x '*.png' a/src/player.py b/src/player.py
--- a/src/player.py	2026-11-04 23:15:17.540752567 -0300
+++ b/src/player.py	2026-11-04 23:19:11.674650613 -0300
@@ -87,87 +87,87 @@
         vx = objmovevec[0]
         vy = objmovevec[1]
         
-        tileocc_ul = self.h_tiledlayers.map_size[0]*((y-11)/16)+((x-(self.sx/2))/16)
-        tileocc_ur = self.h_tiledlayers.map_size[0]*((y-11)/16)+((x+(self.sx/2))/16)
-        tileocc_ll = self.h_tiledlayers.map_size[0]*((y+15)/16)+((x-(self.sx/2))/16)
-        tileocc_lr = self.h_tiledlayers.map_size[0]*((y+15)/16)+((x+(self.sx/2))/16)
+        tileocc_ul = self.h_tiledlayers.map_size[0]*((y-11)//16)+((x-(self.sx//2))//16)
+        tileocc_ur = self.h_tiledlayers.map_size[0]*((y-11)//16)+((x+(self.sx//2))//16)
+        tileocc_ll = self.h_tiledlayers.map_size[0]*((y+15)//16)+((x-(self.sx//2))//16)
+        tileocc_lr = self.h_tiledlayers.map_size[0]*((y+15)//16)+((x+(self.sx//2))//16)
         
-        tileocc_ml = self.h_tiledlayers.map_size[0]*(y/16)+((x-(self.sx/2))/16)
-        tileocc_mr = self.h_tiledlayers.map_size[0]*(y/16)+((x+(self.sx/2))/16)
+        tileocc_ml = self.h_tiledlayers.map_size[0]*(y//16)+((x-(self.sx//2))//16)
+        tileocc_mr = self.h_tiledlayers.map_size[0]*(y//16)+((x+(self.sx//2))//16)
         
         if vx > 0 and self.h_tiledlayers.occlayer[tileocc_mr]:
-            x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
+            x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
         if vx < 0 and self.h_tiledlayers.occlayer[tileocc_ml]:
-            x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
+            x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
         
         if vx > 0 and vy == 0:
             if self.h_tiledlayers.occlayer[tileocc_ur] or self.h_tiledlayers.occlayer[tileocc_lr]:
-                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
+                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
         elif vx < 0 and vy == 0:
             if self.h_tiledlayers.occlayer[tileocc_ul] or self.h_tiledlayers.occlayer[tileocc_ll]:
-                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
+                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
         elif vx == 0 and vy > 0:
             if self.h_tiledlayers.occlayer[tileocc_lr] or self.h_tiledlayers.occlayer[tileocc_ll]:
-                y = 16*(tileocc_ll/self.h_tiledlayers.map_size[0]) - 1 - 16
+                y = 16*(tileocc_ll//self.h_tiledlayers.map_size[0]) - 1 - 16
         elif vx == 0 and vy < 0:
             if self.h_tiledlayers.occlayer[tileocc_ul] or self.h_tiledlayers.occlayer[tileocc_ur]:
-                y = 16*(tileocc_ul/self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
+                y = 16*(tileocc_ul//self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
         elif vx > 0 and vy < 0:
             if self.h_tiledlayers.occlayer[tileocc_ul] and self.h_tiledlayers.occlayer[tileocc_lr]:
-                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
-                y = 16*(tileocc_ul/self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
+                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
+                y = 16*(tileocc_ul//self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
             elif self.h_tiledlayers.occlayer[tileocc_ul]:
-                y = 16*(tileocc_ul/self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
+                y = 16*(tileocc_ul//self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
             elif self.h_tiledlayers.occlayer[tileocc_lr]:
-                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
+                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
             elif self.h_tiledlayers.occlayer[tileocc_ur]:
-                xref = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
-                yref = 16*(tileocc_ul/self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
+                xref = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
+                yref = 16*(tileocc_ul//self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
                 if fabs(x-xref) < fabs(y-yref) or self.h_tiledlayers.occlayer[tileocc_ur+self.h_tiledlayers.map_size[0]]:
                     x = xref
                 else:
                     y = yref
         elif vx > 0 and vy > 0:
             if self.h_tiledlayers.occlayer[tileocc_ll] and self.h_tiledlayers.occlayer[tileocc_ur]:
-                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
-                y = 16*(tileocc_ll/self.h_tiledlayers.map_size[0]) - 1 - 16
+                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
+                y = 16*(tileocc_ll//self.h_tiledlayers.map_size[0]) - 1 - 16
             elif self.h_tiledlayers.occlayer[tileocc_ll]:
-                y = 16*(tileocc_ll/self.h_tiledlayers.map_size[0]) - 1 - 16
+                y = 16*(tileocc_ll//self.h_tiledlayers.map_size[0]) - 1 - 16
             elif self.h_tiledlayers.occlayer[tileocc_ur]:
-                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
+                x = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
             elif self.h_tiledlayers.occlayer[tileocc_lr]:
-                xref = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx/2)
-                yref = 16*(tileocc_ll/self.h_tiledlayers.map_size[0]) - 1 - 16
+                xref = 16*(tileocc_ur % self.h_tiledlayers.map_size[0]) - 1 - (self.sx//2)
+                yref = 16*(tileocc_ll//self.h_tiledlayers.map_size[0]) - 1 - 16
                 if fabs(x-xref) < fabs(y-yref) or self.h_tiledlayers.occlayer[tileocc_lr-self.h_tiledlayers.map_size[0]]:
                     x = xref
                 else:
                     y = yref
         elif vx < 0 and vy > 0:
             if self.h_tiledlayers.occlayer[tileocc_ul] and self.h_tiledlayers.occlayer[tileocc_lr]:
-                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
-                y = 16*(tileocc_ll/self.h_tiledlayers.map_size[0]) - 1 - 16
+                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
+                y = 16*(tileocc_ll//self.h_tiledlayers.map_size[0]) - 1 - 16
             elif self.h_tiledlayers.occlayer[tileocc_lr]:
-                y = 16*(tileocc_ll/self.h_tiledlayers.map_size[0]) - 1 - 16
+                y = 16*(tileocc_ll//self.h_tiledlayers.map_size[0]) - 1 - 16
             elif self.h_tiledlayers.occlayer[tileocc_ul]:
-                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
+                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
             elif self.h_tiledlayers.occlayer[tileocc_ll]:
-                xref = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
-                yref = 16*(tileocc_ll/self.h_tiledlayers.map_size[0]) - 1 - 16
+                xref = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
+                yref = 16*(tileocc_ll//self.h_tiledlayers.map_size[0]) - 1 - 16
                 if fabs(x-xref) < fabs(y-yref) or self.h_tiledlayers.occlayer[tileocc_ll-self.h_tiledlayers.map_size[0]]:
                     x = xref
                 else:
                     y = yref
         elif vx < 0 and vy < 0:
             if self.h_tiledlayers.occlayer[tileocc_ur] and self.h_tiledlayers.occlayer[tileocc_ll]:
-                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
-                y = 16*(tileocc_ul/self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
+                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
+                y = 16*(tileocc_ul//self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
             elif self.h_tiledlayers.occlayer[tileocc_ur]:
-                y = 16*(tileocc_ul/self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
+                y = 16*(tileocc_ul//self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
             elif self.h_tiledlayers.occlayer[tileocc_ll]:
-                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
+                x = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
             elif self.h_tiledlayers.occlayer[tileocc_ul]:
-                xref = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx/2)
-                yref = 16*(tileocc_ul/self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
+                xref = 16*(tileocc_ul % self.h_tiledlayers.map_size[0]) + 16 + 1 + (self.sx//2)
+                yref = 16*(tileocc_ul//self.h_tiledlayers.map_size[0]) + 16 + 1 + 12
                 if fabs(x-xref) < fabs(y-yref) or self.h_tiledlayers.occlayer[tileocc_ul+self.h_tiledlayers.map_size[0]]:
                     x = xref
                 else:
@@ -183,80 +183,80 @@
         vy = objmovevec[1]
         ts = 16
         
-        tileocc_ul = (y-11) < box.y+(ts/2) and (y-11) > box.y-(ts/2) and (x-(self.sx/2)) < box.x+(ts/2) and (x-(self.sx/2)) > box.x-(ts/2)
-        tileocc_ur = (y-11) < box.y+(ts/2) and (y-11) > box.y-(ts/2) and (x+(self.sx/2)) < box.x+(ts/2) and (x+(self.sx/2)) > box.x-(ts/2)
-        tileocc_ll = (y+15) < box.y+(ts/2) and (y+15) > box.y-(ts/2) and (x-(self.sx/2)) < box.x+(ts/2) and (x-(self.sx/2)) > box.x-(ts/2)
-        tileocc_lr = (y+15) < box.y+(ts/2) and (y+15) > box.y-(ts/2) and (x+(self.sx/2)) < box.x+(ts/2) and (x+(self.sx/2)) > box.x-(ts/2)
+        tileocc_ul = (y-11) < box.y+(ts//2) and (y-11) > box.y-(ts//2) and (x-(self.sx//2)) < box.x+(ts//2) and (x-(self.sx//2)) > box.x-(ts//2)
+        tileocc_ur = (y-11) < box.y+(ts//2) and (y-11) > box.y-(ts//2) and (x+(self.sx//2)) < box.x+(ts//2) and (x+(self.sx//2)) > box.x-(ts//2)
+        tileocc_ll = (y+15) < box.y+(ts//2) and (y+15) > box.y-(ts//2) and (x-(self.sx//2)) < box.x+(ts//2) and (x-(self.sx//2)) > box.x-(ts//2)
+        tileocc_lr = (y+15) < box.y+(ts//2) and (y+15) > box.y-(ts//2) and (x+(self.sx//2)) < box.x+(ts//2) and (x+(self.sx//2)) > box.x-(ts//2)
         
-        tileocc_ml = y < box.y+(ts/2) and y > box.y-(ts/2) and (x-(self.sx/2)) < box.x+(ts/2) and (x-(self.sx/2)) > box.x-(ts/2)
-        tileocc_mr = y < box.y+(ts/2) and y > box.y-(ts/2) and (x+(self.sx/2)) < box.x+(ts/2) and (x+(self.sx/2)) > box.x-(ts/2)
+        tileocc_ml = y < box.y+(ts//2) and y > box.y-(ts//2) and (x-(self.sx//2)) < box.x+(ts//2) and (x-(self.sx//2)) > box.x-(ts//2)
+        tileocc_mr = y < box.y+(ts//2) and y > box.y-(ts//2) and (x+(self.sx//2)) < box.x+(ts//2) and (x+(self.sx//2)) > box.x-(ts//2)
         
         #print x,y,box.x,box.y
         #print tileocc_ul,tileocc_ur,tileocc_ll,tileocc_lr,tileocc_ml,tileocc_mr
         
         if vx > 0 and tileocc_mr:
-            x = box.x-(ts/2) - (self.sx/2) - 1
+            x = box.x-(ts//2) - (self.sx//2) - 1
             #print "b"
         if vx < 0 and tileocc_ml:
-            x = box.x+(ts/2) + (self.sx/2) + 1
+            x = box.x+(ts//2) + (self.sx//2) + 1
         
         if vx > 0 and vy == 0:
             if tileocc_ur or tileocc_lr:
-                x = box.x-(ts/2) - (self.sx/2) - 1
+                x = box.x-(ts//2) - (self.sx//2) - 1
                 #print "a"
         elif vx < 0 and vy == 0:
             if tileocc_ul or tileocc_ll:
-                x = box.x+(ts/2) + (self.sx/2) + 1
+                x = box.x+(ts//2) + (self.sx//2) + 1
         elif vx == 0 and vy > 0:
             if tileocc_lr or tileocc_ll:
-                y = box.y-(ts/2) - 16 - 1
+                y = box.y-(ts//2) - 16 - 1
         elif vx == 0 and vy < 0:
             if tileocc_ul or tileocc_ur:
-                y = box.y+(ts/2) + 12 + 1
+                y = box.y+(ts//2) + 12 + 1
         elif vx > 0 and vy < 0:
             if tileocc_ul:
-                y = box.y+(ts/2) + 12 + 1
+                y = box.y+(ts//2) + 12 + 1
             elif tileocc_lr:
-                x = box.x-(ts/2) - (self.sx/2) - 1
+                x = box.x-(ts//2) - (self.sx//2) - 1
             elif tileocc_ur:
-                xref = box.x-(ts/2) - (self.sx/2) - 1
-                yref = box.y+(ts/2) + 12 + 1
+                xref = box.x-(ts//2) - (self.sx//2) - 1
+                yref = box.y+(ts//2) + 12 + 1
                 if fabs(x-xref) < fabs(y-yref):
                     x = xref
                 else:
                     y = yref
         elif vx > 0 and vy > 0:
             if tileocc_ll:
-                y = box.y-(ts/2) - 16 - 1
+                y = box.y-(ts//2) - 16 - 1
             elif tileocc_ur:
-                x = box.x-(ts/2) - (self.sx/2) - 1
+                x = box.x-(ts//2) - (self.sx//2) - 1
             elif tileocc_lr:
-                xref = box.x-(ts/2) - (self.sx/2) - 1
-                yref = box.y-(ts/2) - 16 - 1
+                xref = box.x-(ts//2) - (self.sx//2) - 1
+                yref = box.y-(ts//2) - 16 - 1
                 if fabs(x-xref) < fabs(y-yref):
                     x = xref
                 else:
                     y = yref
         elif vx < 0 and vy > 0:
             if tileocc_lr:
-                y = box.y-(ts/2) - 16 - 1
+                y = box.y-(ts//2) - 16 - 1
             elif tileocc_ul:
-                x = box.x+(ts/2) + (self.sx/2) + 1
+                x = box.x+(ts//2) + (self.sx//2) + 1
             elif tileocc_ll:
-                xref = box.x+(ts/2) + (self.sx/2) + 1
-                yref = box.y-(ts/2) - 16 - 1
+                xref = box.x+(ts//2) + (self.sx//2) + 1
+                yref = box.y-(ts//2) - 16 - 1
                 if fabs(x-xref) < fabs(y-yref):
                     x = xref
                 else:
                     y = yref
         elif vx < 0 and vy < 0:
             if tileocc_ur:
-                y = box.y+(ts/2) + 12 + 1
+                y = box.y+(ts//2) + 12 + 1
             elif tileocc_ll:
-                x = box.x+(ts/2) + (self.sx/2) + 1
+                x = box.x+(ts//2) + (self.sx//2) + 1
             elif tileocc_ul:
-                xref = box.x+(ts/2) + (self.sx/2) + 1
-                yref = box.y+(ts/2) + 12 + 1
+                xref = box.x+(ts//2) + (self.sx//2) + 1
+                yref = box.y+(ts//2) + 12 + 1
                 if fabs(x-xref) < fabs(y-yref):
                     x = xref
                 else:
@@ -265,7 +265,7 @@
         return (x,y)
     
     def ExitCheck(self):
-        current_tile = self.h_tiledlayers.map_size[0]*((self.y+4)/self.h_tiledlayers.tilesize)+(self.x/self.h_tiledlayers.tilesize)
+        current_tile = self.h_tiledlayers.map_size[0]*((self.y+4)//self.h_tiledlayers.tilesize)+(self.x//self.h_tiledlayers.tilesize)
         exit_tiles = []
         exit_tiles2 = []
         for exit in self.h_tiledlayers.exit_data:
@@ -283,7 +283,7 @@
         if self.exiting or self.dying:
             return
         
-        init_tile = self.h_tiledlayers.map_size[0]*((self.y+4)/self.h_tiledlayers.tilesize)+(self.x/self.h_tiledlayers.tilesize)
+        init_tile = self.h_tiledlayers.map_size[0]*((self.y+4)//self.h_tiledlayers.tilesize)+(self.x//self.h_tiledlayers.tilesize)
         ts = self.h_tiledlayers.tilesize
         
         # Compute inertia
@@ -307,7 +307,7 @@
         
         # Don't fall off the map
         self.x = min(self.x, (self.h_tiledlayers.map_size[0]-1)*16)
-        self.x = max(self.x, 0+(self.sx/2))
+        self.x = max(self.x, 0+(self.sx//2))
         self.y = min(self.y, (self.h_tiledlayers.map_size[1]-1)*16)
         self.y = max(self.y, 0+16)
         
@@ -316,18 +316,18 @@
         #(x2,y2) = self.h_tiledlayers.HandleObjectWallCollision((self.x,self.y),(20,26),(vx,self.vy))
         
         # Handle pushing boxes
-        new_tile = self.h_tiledlayers.map_size[0]*((self.y+4)/16)+(self.x/16)
+        new_tile = self.h_tiledlayers.map_size[0]*((self.y+4)//16)+(self.x//16)
         idlist = self.h_tiledlayers.FindMechanisms(new_tile,'block')
         ground_state_on_block = False
         for id in idlist:
             block = self.h_tiledlayers.movingblocks[id-100]
-            checkx = self.x+(self.sx/2) > (block.x-ts/2) and self.x-(self.sx/2) < (block.x+ts/2)
-            checky = self.y+(32/2) > (block.y-ts/2) and self.y-(32/2) < (block.y+ts/2)
-            checkx2 = self.x+(self.sx/2) > (block.x-ts/2) and self.x-(self.sx/2) < (block.x+ts/2)
-            checky2 = self.y+(32/2) >= (block.y-ts/2) and self.y+(32/2) < (block.y-(ts/2)+15)
+            checkx = self.x+(self.sx//2) > (block.x-ts//2) and self.x-(self.sx//2) < (block.x+ts//2)
+            checky = self.y+(32//2) > (block.y-ts//2) and self.y-(32//2) < (block.y+ts//2)
+            checkx2 = self.x+(self.sx//2) > (block.x-ts//2) and self.x-(self.sx//2) < (block.x+ts//2)
+            checky2 = self.y+(32//2) >= (block.y-ts//2) and self.y+(32//2) < (block.y-(ts//2)+15)
             if checkx2 and checky2 and self.vy >= 0 and block.ground_state:
                 ground_state_on_block = True
-                self.y = block.y-(ts/2)-(32/2)
+                self.y = block.y-(ts//2)-(32//2)
             elif checkx and checky:
                 #if self.ground_state and self.control.use:
                 if self.ground_state:
@@ -336,19 +336,19 @@
             (self.x,self.y) = self.HandleBoxCollision((self.x,self.y),(vx,self.vy),block)
         
         # Handle platforms
-        new_tile = self.h_tiledlayers.map_size[0]*((self.y+4)/16)+(self.x/16)
+        new_tile = self.h_tiledlayers.map_size[0]*((self.y+4)//16)+(self.x//16)
         idlist = self.h_tiledlayers.FindMechanisms(new_tile,'platform')
         ground_state_on_platform = False
         for id in idlist:
             platform = self.h_tiledlayers.platformcontrol.platforms[id-300]
-            checkx2 = self.x+(self.sx/2) > (platform.x-ts/2) and self.x-(self.sx/2) < (platform.x+2*ts+ts/2)
-            checky2 = self.y+(32/2) >= (platform.y-ts/2) and self.y+(32/2) < (platform.y-(ts/2)+15)
+            checkx2 = self.x+(self.sx//2) > (platform.x-ts//2) and self.x-(self.sx//2) < (platform.x+2*ts+ts//2)
+            checky2 = self.y+(32//2) >= (platform.y-ts//2) and self.y+(32//2) < (platform.y-(ts//2)+15)
             if checkx2 and checky2 and self.vy >= 0:
                 ground_state_on_platform = True
-                self.y = platform.y-(ts/2)-(32/2)  
+                self.y = platform.y-(ts//2)-(32//2)  
                     
         # Check if need to inform tilemap object layer of updates
-        final_tile = self.h_tiledlayers.map_size[0]*((self.y+4)/16)+(self.x/16)
+        final_tile = self.h_tiledlayers.map_size[0]*((self.y+4)//16)+(self.x//16)
         if not init_tile == final_tile:
             self.h_tiledlayers.UpdateObj(init_tile,final_tile,0)
         
@@ -358,15 +358,15 @@
             if eid >= 0: # check for opening door/exit
                 self.exiting = True
                 self.x = self.h_tiledlayers.tilesize*(self.h_tiledlayers.exit_data[eid][0]%self.h_tiledlayers.map_size[0])+16
-                self.y = self.h_tiledlayers.tilesize*(self.h_tiledlayers.exit_data[eid][0]/self.h_tiledlayers.map_size[0])
+                self.y = self.h_tiledlayers.tilesize*(self.h_tiledlayers.exit_data[eid][0]//self.h_tiledlayers.map_size[0])
                 self.gaittype = 'exit'
                 self.gait = 0
                 self.destination = [self.h_tiledlayers.exit_data[eid][1],self.h_tiledlayers.exit_data[eid][2]]
                 return
         
         # Check for ground state
-        leftfoottile = self.h_tiledlayers.map_size[0]*((self.y+16+1)/self.h_tiledlayers.tilesize)+((self.x-8)/self.h_tiledlayers.tilesize)
-        rightfoottile = self.h_tiledlayers.map_size[0]*((self.y+16+1)/self.h_tiledlayers.tilesize)+((self.x+8)/self.h_tiledlayers.tilesize)
+        leftfoottile = self.h_tiledlayers.map_size[0]*((self.y+16+1)//self.h_tiledlayers.tilesize)+((self.x-8)//self.h_tiledlayers.tilesize)
+        rightfoottile = self.h_tiledlayers.map_size[0]*((self.y+16+1)//self.h_tiledlayers.tilesize)+((self.x+8)//self.h_tiledlayers.tilesize)
         if (self.vy >= 0 and (self.h_tiledlayers.occlayer[leftfoottile] == 1 or self.h_tiledlayers.occlayer[rightfoottile] == 1) or ground_state_on_block or ground_state_on_platform):
             self.ground_state = True
         else:
@@ -377,11 +377,11 @@
         for id in idlist:
             block = self.h_tiledlayers.hurtblockcontrol.blocks[id-400]
             if block.type == 'lava':
-                checkx = self.x+(self.sx/2) >= ts*(block.tile%self.h_tiledlayers.map_size[0])-1 and self.x-(self.sx/2) <= ts*(block.tile%self.h_tiledlayers.map_size[0])+ts+1
-                checky = self.y+(32/2) >= ts*(block.tile/self.h_tiledlayers.map_size[0])+8 and self.y-(32/2) <= ts*(block.tile/self.h_tiledlayers.map_size[0])+ts+1
+                checkx = self.x+(self.sx//2) >= ts*(block.tile%self.h_tiledlayers.map_size[0])-1 and self.x-(self.sx//2) <= ts*(block.tile%self.h_tiledlayers.map_size[0])+ts+1
+                checky = self.y+(32//2) >= ts*(block.tile//self.h_tiledlayers.map_size[0])+8 and self.y-(32//2) <= ts*(block.tile//self.h_tiledlayers.map_size[0])+ts+1
             else:
-                checkx = self.x+(self.sx/2) >= ts*(block.tile%self.h_tiledlayers.map_size[0])-1 and self.x-(self.sx/2) <= ts*(block.tile%self.h_tiledlayers.map_size[0])+ts+1
-                checky = self.y+(32/2) >= ts*(block.tile/self.h_tiledlayers.map_size[0])-1 and self.y-(32/2) <= ts*(block.tile/self.h_tiledlayers.map_size[0])+ts+1
+                checkx = self.x+(self.sx//2) >= ts*(block.tile%self.h_tiledlayers.map_size[0])-1 and self.x-(self.sx//2) <= ts*(block.tile%self.h_tiledlayers.map_size[0])+ts+1
+                checky = self.y+(32//2) >= ts*(block.tile//self.h_tiledlayers.map_size[0])-1 and self.y-(32//2) <= ts*(block.tile//self.h_tiledlayers.map_size[0])+ts+1
             if checkx and checky:
                 if block.switched_on:
                     if block.type == 'lava':
@@ -416,5 +416,5 @@
     def Draw(self,screen):
         tilecoords = resources.player_spritesheet_coords[self.heading][resources.player_spriteseq[self.gaittype][self.gait]]
         #screen.blit(resources.player_spritesheet, (self.x-(self.sizex/2)-self.h_camera.x+self.h_camera.w_view/2,self.y-(self.sizey/2)-self.h_camera.y+self.h_camera.h_view/2), area=tilecoords)
-        screen.blit(resources.player_spritesheet, (self.x-(self.sizex/2)-self.h_camera.x+self.h_camera.w_view/2,self.y-12-self.h_camera.y+self.h_camera.h_view/2), area=tilecoords)
+        screen.blit(resources.player_spritesheet, (self.x-(self.sizex//2)-self.h_camera.x+self.h_camera.w_view//2,self.y-12-self.h_camera.y+self.h_camera.h_view//2), area=tilecoords)
 
diff -ruN -x '*.png' a/src/resources.py b/src/resources.py
--- a/src/resources.py	2026-11-04 23:15:17.541965102 -0300
+++ b/src/resources.py	2026-11-04 23:19:11.680994827 -0300
@@ -19,7 +19,7 @@
         self.player_start_tile = [int(i) for i in f.readline().split()][0]
         numexits = [int(i) for i in f.readline().split()][0]
         self.exit_data = []
-        for i in xrange(numexits):
+        for i in range(numexits):
             data = f.readline().split()
             self.exit_data.append((int(data[0]),data[1],int(data[2])))
         self.music = f.readline().split()[0]
@@ -28,37 +28,37 @@
         self.tilelayer_mg = []
         self.tilelayer_fg = []
         self.occlayer = []
-        for j in xrange(self.map_size[1]):
+        for j in range(self.map_size[1]):
             self.tilelayer_bg.extend([int(i) for i in f.readline().split()])
-        for j in xrange(self.map_size[1]):
+        for j in range(self.map_size[1]):
             self.tilelayer_mg.extend([int(i) for i in f.readline().split()])
-        for j in xrange(self.map_size[1]):
+        for j in range(self.map_size[1]):
             self.tilelayer_fg.extend([int(i) for i in f.readline().split()])
-        for j in xrange(self.map_size[1]):
+        for j in range(self.map_size[1]):
             self.occlayer.extend([int(i) for i in f.readline().split()])
         self.movingblockdata = [int(i) for i in f.readline().split()]
         numhurtblocks = [int(i) for i in f.readline().split()][0]
         self.hurtblockdata = []
-        for i in xrange(numhurtblocks):
+        for i in range(numhurtblocks):
             data = f.readline().split()
             self.hurtblockdata.append((int(data[0]),data[1]))
         numplatforms = [int(i) for i in f.readline().split()][0]
         self.platformdata = []
-        for i in xrange(numplatforms):
+        for i in range(numplatforms):
             data = f.readline().split()
             self.platformdata.append((int(data[0]),int(data[1]),int(data[2]),data[3],int(data[4])))
         numdoors = [int(i) for i in f.readline().split()][0]
         self.doordata = []
-        for i in xrange(numdoors):
+        for i in range(numdoors):
             data = f.readline().split()
             self.doordata.append((int(data[0]),data[1],data[2]))
         numbuttons = [int(i) for i in f.readline().split()][0]
         self.buttondata = []
-        for i in xrange(numbuttons):
+        for i in range(numbuttons):
             data = f.readline().split()
             self.buttondata.append((int(data[0]),data[1],[]))
             nmech = int(data[2]) # number of mechanisms controlled
-            for j in xrange(nmech):
+            for j in range(nmech):
                 data = f.readline().split()
                 self.buttondata[-1][2].append((data[0],int(data[1]))) # type, ind
         self.killerbatdata = [int(i) for i in f.readline().split()]
@@ -71,12 +71,12 @@
         
         keys = list('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ? = abcdefghijklmnopqrstuvwxyz+,-.!"#$%&`():')
         self.rects = {}
-        for i in xrange(8):
-            for j in xrange(10):
+        for i in range(8):
+            for j in range(10):
                 k = keys[i*10+j]
                 self.rects[k] = [j*size[0],i*size[1],size[0],size[1]]
-        self.rects['i'][2] = size[1]/5
-        self.rects['l'][2] = size[1]/5
+        self.rects['i'][2] = size[1]//5
+        self.rects['l'][2] = size[1]//5
     
     def RenderSentence(self, sentence, maxx, maxy, align='left'):
         sentsurf = pygame.Surface((maxx,maxy))
@@ -84,7 +84,7 @@
         sentsurf.convert()
         sentsurf.set_colorkey((255,0,255))
         textheight = self.rects['A'][3]
-        maxlines = maxy/textheight
+        maxlines = maxy//textheight
         linedist = 0
         line = 0
         offsets = []
@@ -96,7 +96,7 @@
                     return False
                 if (linedist+wordsize) >= maxx:
                     line += 1
-                    offsets.append((maxx-linedist)/2)
+                    offsets.append((maxx-linedist)//2)
                     linedist = 0
                     if line == maxlines:
                         return False
@@ -104,10 +104,10 @@
                     linedist += self.rects[let][2]
                 if word[-1] == '\n':
                     line += 1
-                    offsets.append((maxx-linedist)/2)
+                    offsets.append((maxx-linedist)//2)
                     linedist = 0
-            offsets.append((maxx-linedist)/2)
-            voffset = maxy/2 - ((line+1)*textheight)/2
+            offsets.append((maxx-linedist)//2)
+            voffset = maxy//2 - ((line+1)*textheight)//2
             linedist = 0
             line = 0
         for word in sentence.split(' '):
@@ -142,8 +142,8 @@
     tiles = pygame.image.load(os.path.join(mainpath,'data','gfx','tiles_2x.png')).convert()
     tiles.set_colorkey((255,0,255))
     tiles_coords = []
-    for j in xrange(20):
-        for i in xrange(16):
+    for j in range(20):
+        for i in range(16):
             tiles_coords.append((i*18+2, j*18+2, 16, 16))
     
     global tiles_coords_buttons
@@ -182,10 +182,10 @@
     player_spritesheet_coords = {}
     player_spritesheet_coords['left'] = []
     player_spritesheet_coords['right'] = []
-    for i in xrange(2):
+    for i in range(2):
         player_spritesheet_coords['right'].append((i*20, 0, 20, 28))
         player_spritesheet_coords['left'].append((i*20+6*20, 0, 20, 28))
-    for i in xrange(4):
+    for i in range(4):
         player_spritesheet_coords['right'].append((i*20, 28, 20, 28))
         player_spritesheet_coords['left'].append((i*20+4*20, 28, 20, 28))
     player_spriteseq = {}
@@ -206,7 +206,7 @@
     bat_spritesheet_coords['right'] = []
     bat_spritesheet_coords['left'] = []
     bat_spritesheet_coords['right'] = []
-    for i in xrange(4):
+    for i in range(4):
         bat_spritesheet_coords['right'].append((i*20, 0, 20, 20))
         bat_spritesheet_coords['left'].append((i*20+80, 0, 20, 20))
     bat_spriteseq = {}
@@ -286,10 +286,10 @@
     titlescreen_surfs['bg'] = pygame.image.load(os.path.join(mainpath,'data','gfx','title_bg_2x.png')).convert()
     titlescreen_surfs['bg'].set_colorkey((255,0,255))
     
-    titlescreen_surfs['newgame_white'] = gamefont.RenderSentence("New Game", screen_res[0], screen_res[1]/2, align='vcentre')
-    titlescreen_surfs['continue_white'] = gamefont.RenderSentence("Continue", screen_res[0], screen_res[1]/2, align='vcentre')
-    titlescreen_surfs['newgame_red'] = gamefontred.RenderSentence("New Game", screen_res[0], screen_res[1]/2, align='vcentre')
-    titlescreen_surfs['continue_red'] = gamefontred.RenderSentence("Continue", screen_res[0], screen_res[1]/2, align='vcentre')
+    titlescreen_surfs['newgame_white'] = gamefont.RenderSentence("New Game", screen_res[0], screen_res[1]//2, align='vcentre')
+    titlescreen_surfs['continue_white'] = gamefont.RenderSentence("Continue", screen_res[0], screen_res[1]//2, align='vcentre')
+    titlescreen_surfs['newgame_red'] = gamefontred.RenderSentence("New Game", screen_res[0], screen_res[1]//2, align='vcentre')
+    titlescreen_surfs['continue_red'] = gamefontred.RenderSentence("Continue", screen_res[0], screen_res[1]//2, align='vcentre')
     
     ####################
     # Pause Screen Stuff
@@ -366,23 +366,23 @@
     scrolls_img = pygame.image.load(os.path.join(mainpath,'data','gfx','datascrolls_8x.png')).convert()
     scrolls_img.set_colorkey((255,0,255))
     
-    text_red = gamefont.RenderSentence("You got the red data scroll!", screen_res[0], screen_res[1]/2, align='vcentre')
-    text_green = gamefont.RenderSentence("You got the green data scroll!", screen_res[0], screen_res[1]/2, align='vcentre')
-    text_blue = gamefont.RenderSentence("You got the blue data scroll!", screen_res[0], screen_res[1]/2, align='vcentre')
+    text_red = gamefont.RenderSentence("You got the red data scroll!", screen_res[0], screen_res[1]//2, align='vcentre')
+    text_green = gamefont.RenderSentence("You got the green data scroll!", screen_res[0], screen_res[1]//2, align='vcentre')
+    text_blue = gamefont.RenderSentence("You got the blue data scroll!", screen_res[0], screen_res[1]//2, align='vcentre')
     
     gotscroll_surfs = {}
     gotscroll_surfs['scroll_red'] = pygame.Surface((screen_res[0],screen_res[1]))
     gotscroll_surfs['scroll_red'].fill((0,0,0))
-    gotscroll_surfs['scroll_red'].blit(scrolls_img,(screen_res[0]/2-40,screen_res[1]/2-60),area=(80,0,80,80))
-    gotscroll_surfs['scroll_red'].blit(text_red,(0,screen_res[1]/2))
+    gotscroll_surfs['scroll_red'].blit(scrolls_img,(screen_res[0]//2-40,screen_res[1]//2-60),area=(80,0,80,80))
+    gotscroll_surfs['scroll_red'].blit(text_red,(0,screen_res[1]//2))
     gotscroll_surfs['scroll_green'] = pygame.Surface((screen_res[0],screen_res[1]))
     gotscroll_surfs['scroll_green'].fill((0,0,0))
-    gotscroll_surfs['scroll_green'].blit(scrolls_img,(screen_res[0]/2-40,screen_res[1]/2-60),area=(160,0,80,80))
-    gotscroll_surfs['scroll_green'].blit(text_green,(0,screen_res[1]/2))
+    gotscroll_surfs['scroll_green'].blit(scrolls_img,(screen_res[0]//2-40,screen_res[1]//2-60),area=(160,0,80,80))
+    gotscroll_surfs['scroll_green'].blit(text_green,(0,screen_res[1]//2))
     gotscroll_surfs['scroll_blue'] = pygame.Surface((screen_res[0],screen_res[1]))
     gotscroll_surfs['scroll_blue'].fill((0,0,0))
-    gotscroll_surfs['scroll_blue'].blit(scrolls_img,(screen_res[0]/2-40,screen_res[1]/2-60),area=(0,0,80,80))
-    gotscroll_surfs['scroll_blue'].blit(text_blue,(0,screen_res[1]/2))
+    gotscroll_surfs['scroll_blue'].blit(scrolls_img,(screen_res[0]//2-40,screen_res[1]//2-60),area=(0,0,80,80))
+    gotscroll_surfs['scroll_blue'].blit(text_blue,(0,screen_res[1]//2))
     
     # Initial cutscenes
     global cutscenesurfs
diff -ruN -x '*.png' a/src/tilemap.py b/src/tilemap.py
--- a/src/tilemap.py	2026-11-04 23:15:17.538058915 -0300
+++ b/src/tilemap.py	2026-11-04 23:19:11.666417784 -0300
@@ -61,15 +61,15 @@
             for st in steptiles:
                 for id in self.parent.objectlayer[st]:
                     if id == 0 and self.parent.h_player.ground_state:
-                        condx1 = self.parent.h_player.x+(self.parent.h_player.sx/2) > ts*(b.tile%self.parent.map_size[0])
-                        condx2 = self.parent.h_player.x-(self.parent.h_player.sx/2) < ts*(b.tile%self.parent.map_size[0])+ts
+                        condx1 = self.parent.h_player.x+(self.parent.h_player.sx//2) > ts*(b.tile%self.parent.map_size[0])
+                        condx2 = self.parent.h_player.x-(self.parent.h_player.sx//2) < ts*(b.tile%self.parent.map_size[0])+ts
                         if condx1 and condx2:
                             stepped_on = True
                     elif id >= 100 and id < 200:
                         block = self.parent.movingblocks[id-100]
                         if block.ground_state:
-                            condx1 = (block.x+ts/2) > (ts*(b.tile%self.parent.map_size[0]))
-                            condx2 = (block.x-ts/2) < (ts*(b.tile%self.parent.map_size[0])+ts)
+                            condx1 = (block.x+ts//2) > (ts*(b.tile%self.parent.map_size[0]))
+                            condx2 = (block.x-ts//2) < (ts*(b.tile%self.parent.map_size[0])+ts)
                             if condx1 and condx2:
                                 stepped_on = True
             if stepped_on:
@@ -80,9 +80,9 @@
                 resources.soundfx['button'].play()
     
     def DrawButtons(self,screen):
-        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view/2,self.parent.h_camera.y-self.parent.h_camera.h_view/2)
+        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view//2,self.parent.h_camera.y-self.parent.h_camera.h_view//2)
         for b in self.buttons:
-            coords = [(b.tile%self.parent.map_size[0])*self.parent.tilesize, (b.tile/self.parent.map_size[0])*self.parent.tilesize]
+            coords = [(b.tile%self.parent.map_size[0])*self.parent.tilesize, (b.tile//self.parent.map_size[0])*self.parent.tilesize]
             if b.state:
                 tilecoords = resources.tiles_coords_buttons[b.type][1]
             else:
@@ -136,11 +136,11 @@
             block.Update()
     
     def DrawHurtBlocks(self,screen):
-        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view/2,self.parent.h_camera.y-self.parent.h_camera.h_view/2)
+        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view//2,self.parent.h_camera.y-self.parent.h_camera.h_view//2)
         ts = self.parent.tilesize
         for block in self.blocks:
             x = self.parent.tilesize*(block.tile%self.parent.map_size[0])
-            y = self.parent.tilesize*(block.tile/self.parent.map_size[0])
+            y = self.parent.tilesize*(block.tile//self.parent.map_size[0])
             if block.type == 'lava':
                 tilecoords = resources.tiles_coords[resources.tiles_hurtblockseq['lava'][block.frame]]
             else:
@@ -189,9 +189,9 @@
         ts = self.parent.tilesize
         id = len(self.platforms)+300
         x = self.parent.tilesize*(tile_top%self.parent.map_size[0])
-        maxy = ts*(tile_bottom/self.parent.map_size[0])+(ts/2)
-        miny = ts*(tile_top/self.parent.map_size[0])+(ts/2)
-        attach_y = self.parent.tilesize*(attach_tile/self.parent.map_size[0])
+        maxy = ts*(tile_bottom//self.parent.map_size[0])+(ts//2)
+        miny = ts*(tile_top//self.parent.map_size[0])+(ts//2)
+        attach_y = self.parent.tilesize*(attach_tile//self.parent.map_size[0])
         self.platforms.append(MovingPlatform(x,miny,maxy,attach_y,speed,type,id))
         if type == 'lower':
             self.parent.InsertObj(tile_top,id)
@@ -205,24 +205,24 @@
     def UpdatePlatforms(self):
         ts = self.parent.tilesize
         for p in self.platforms:
-            init_tile = self.parent.map_size[0]*(p.y/ts)+((p.x+(ts/2))/ts)
+            init_tile = self.parent.map_size[0]*(p.y//ts)+((p.x+(ts//2))//ts)
             p.Update()
-            final_tile = self.parent.map_size[0]*(p.y/ts)+((p.x+(ts/2))/ts)
+            final_tile = self.parent.map_size[0]*(p.y//ts)+((p.x+(ts//2))//ts)
             if not init_tile == final_tile:
                 self.parent.UpdateObj(init_tile,final_tile,p.id)
                 self.parent.UpdateObj(init_tile+1,final_tile+1,p.id)
                 self.parent.UpdateObj(init_tile+2,final_tile+2,p.id)
     
     def DrawPlatforms(self,screen):
-        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view/2,self.parent.h_camera.y-self.parent.h_camera.h_view/2)
+        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view//2,self.parent.h_camera.y-self.parent.h_camera.h_view//2)
         ts = self.parent.tilesize
         for p in self.platforms:
             tilecoords1 = resources.tiles_coords[resources.tiles_platform['base_coords'][0]]
             tilecoords2 = resources.tiles_coords[resources.tiles_platform['base_coords'][1]]
             tilecoords3 = resources.tiles_coords[resources.tiles_platform['base_coords'][2]]
-            screen.blit(resources.tiles, (p.x-camerax,p.y-(ts/2)-cameray), area=tilecoords1)
-            screen.blit(resources.tiles, (p.x+ts-camerax,p.y-(ts/2)-cameray), area=tilecoords2)
-            screen.blit(resources.tiles, (p.x+2*ts-camerax,p.y-(ts/2)-cameray), area=tilecoords3)
+            screen.blit(resources.tiles, (p.x-camerax,p.y-(ts//2)-cameray), area=tilecoords1)
+            screen.blit(resources.tiles, (p.x+ts-camerax,p.y-(ts//2)-cameray), area=tilecoords2)
+            screen.blit(resources.tiles, (p.x+2*ts-camerax,p.y-(ts//2)-cameray), area=tilecoords3)
             
             link_len = 12
             linkbase_len = 14
@@ -230,19 +230,19 @@
             tilecoords_chain_left_partial = list(tilecoords_chain_left)
             tilecoords_chain_right = resources.tiles_platform['chainlink']['right']
             tilecoords_chain_right_partial = list(tilecoords_chain_right)
-            chain_len = p.y-(ts/2)-p.attach_y-linkbase_len
-            nlinks = chain_len/link_len
+            chain_len = p.y-(ts//2)-p.attach_y-linkbase_len
+            nlinks = chain_len//link_len
             offset = chain_len%link_len
             tilecoords_chain_left_partial[1] = tilecoords_chain_left_partial[1] + (link_len-offset)
             tilecoords_chain_left_partial[3] = offset
             tilecoords_chain_right_partial[1] = tilecoords_chain_right_partial[1] + (link_len-offset)
             tilecoords_chain_right_partial[3] = offset
             
-            screen.blit(resources.tiles, (p.x-camerax,p.y-(ts/2)-ts-cameray), area=resources.tiles_platform['chainbase']['left'])
-            screen.blit(resources.tiles, (p.x+2*ts-camerax,p.y-(ts/2)-ts-cameray), area=resources.tiles_platform['chainbase']['right'])
-            for i in xrange(nlinks):
-                screen.blit(resources.tiles, (p.x-camerax,p.y-(ts/2)-linkbase_len-link_len*(i+1)-cameray), area=tilecoords_chain_left)
-                screen.blit(resources.tiles, (p.x+2*ts-camerax,p.y-(ts/2)-linkbase_len-link_len*(i+1)-cameray), area=tilecoords_chain_right)
+            screen.blit(resources.tiles, (p.x-camerax,p.y-(ts//2)-ts-cameray), area=resources.tiles_platform['chainbase']['left'])
+            screen.blit(resources.tiles, (p.x+2*ts-camerax,p.y-(ts//2)-ts-cameray), area=resources.tiles_platform['chainbase']['right'])
+            for i in range(nlinks):
+                screen.blit(resources.tiles, (p.x-camerax,p.y-(ts//2)-linkbase_len-link_len*(i+1)-cameray), area=tilecoords_chain_left)
+                screen.blit(resources.tiles, (p.x+2*ts-camerax,p.y-(ts//2)-linkbase_len-link_len*(i+1)-cameray), area=tilecoords_chain_right)
             screen.blit(resources.tiles, (p.x-camerax,p.attach_y-cameray), area=tilecoords_chain_left_partial)
             screen.blit(resources.tiles, (p.x+2*ts-camerax,p.attach_y-cameray), area=tilecoords_chain_right_partial)
 
@@ -306,7 +306,7 @@
             d.Update()
     
     def DrawDoors(self,screen):
-        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view/2,self.parent.h_camera.y-self.parent.h_camera.h_view/2)
+        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view//2,self.parent.h_camera.y-self.parent.h_camera.h_view//2)
         ts = self.parent.tilesize
         msx = self.parent.map_size[0]
         for d in self.doors:
@@ -315,12 +315,12 @@
             elif d.type == 'horizontal':
                 tiles = [d.tile,d.tile+1,d.tile+2]
             x1 = ts*(tiles[0]%msx)
-            y1 = ts*(tiles[0]/msx)
+            y1 = ts*(tiles[0]//msx)
             x2 = ts*(tiles[1]%msx)
-            y2 = ts*(tiles[1]/msx)
+            y2 = ts*(tiles[1]//msx)
             x3 = ts*(tiles[2]%msx)
-            y3 = ts*(tiles[2]/msx)
-            frame = d.position/d.ticksperframe
+            y3 = ts*(tiles[2]//msx)
+            frame = d.position//d.ticksperframe
             tilecoords1 = resources.tiles_coords[resources.tiles_doorseq[d.type][0][frame]]
             tilecoords2 = resources.tiles_coords[resources.tiles_doorseq[d.type][1][frame]]
             tilecoords3 = resources.tiles_coords[resources.tiles_doorseq[d.type][2][frame]]
@@ -332,8 +332,8 @@
 class MovingBlock(object):
     def __init__(self,parent,init_tile,id):
         self.parent = parent
-        self.x = self.parent.tilesize*(init_tile%self.parent.map_size[0])+(self.parent.tilesize/2)
-        self.y = self.parent.tilesize*(init_tile/self.parent.map_size[0])+(self.parent.tilesize/2)-1
+        self.x = self.parent.tilesize*(init_tile%self.parent.map_size[0])+(self.parent.tilesize//2)
+        self.y = self.parent.tilesize*(init_tile//self.parent.map_size[0])+(self.parent.tilesize//2)-1
         self.vy = 0
         self.vx = 0
         self.ground_state = True
@@ -344,7 +344,7 @@
     
     def UpdateMotion(self):
         
-        init_tile = self.parent.map_size[0]*(self.y/self.parent.tilesize)+(self.x/self.parent.tilesize)
+        init_tile = self.parent.map_size[0]*(self.y//self.parent.tilesize)+(self.x//self.parent.tilesize)
         
         if self.ground_state == False:
             self.vy = min(self.vy + 1, 5)
@@ -356,7 +356,7 @@
         (self.x,self.y) = self.parent.HandleObjectWallCollision((self.x,self.y),(self.parent.tilesize,self.parent.tilesize),(0,self.vy))
         
         # check for on top of other boxes
-        current_tile = self.parent.map_size[0]*(self.y/self.parent.tilesize)+(self.x/self.parent.tilesize)
+        current_tile = self.parent.map_size[0]*(self.y//self.parent.tilesize)+(self.x//self.parent.tilesize)
         idlist = self.parent.FindMechanisms(current_tile,'block')
         ts = self.parent.tilesize
         ground_state_on_block = False
@@ -364,33 +364,33 @@
             if id == self.id:
                 continue
             block = self.parent.movingblocks[id-100]
-            checkx2 = self.x+(ts/2) > (block.x-ts/2) and self.x-(ts/2) < (block.x+ts/2)
-            checky2 = self.y+(ts/2) >= (block.y-ts/2) and self.y+(ts/2) < (block.y-(ts/2)+15)
+            checkx2 = self.x+(ts//2) > (block.x-ts//2) and self.x-(ts//2) < (block.x+ts//2)
+            checky2 = self.y+(ts//2) >= (block.y-ts//2) and self.y+(ts//2) < (block.y-(ts//2)+15)
             if checkx2 and checky2 and self.vy >= 0:
                 ground_state_on_block = True
                 self.y = block.y-ts
         
         # check for on top of platforms
-        current_tile = self.parent.map_size[0]*(self.y/self.parent.tilesize)+(self.x/self.parent.tilesize)
+        current_tile = self.parent.map_size[0]*(self.y//self.parent.tilesize)+(self.x//self.parent.tilesize)
         idlist = self.parent.FindMechanisms(current_tile,'platform')
         ts = self.parent.tilesize
         ground_state_on_platform = False
         for id in idlist:
             platform = self.parent.platformcontrol.platforms[id-300]
-            checkx2 = self.x+(ts/2) > (platform.x-ts/2) and self.x-(ts/2) < (platform.x+ts*2+ts/2)
-            checky2 = self.y+(ts/2) >= (platform.y-ts/2-1) and self.y+(ts/2) < (platform.y-(ts/2)+15)
+            checkx2 = self.x+(ts//2) > (platform.x-ts//2) and self.x-(ts//2) < (platform.x+ts*2+ts//2)
+            checky2 = self.y+(ts//2) >= (platform.y-ts//2-1) and self.y+(ts//2) < (platform.y-(ts//2)+15)
             if checkx2 and checky2:
                 ground_state_on_platform = True
                 self.y = platform.y-ts-1
         
         # Check if need to inform tilemap object layer of updates
-        final_tile = self.parent.map_size[0]*(self.y/self.parent.tilesize)+(self.x/self.parent.tilesize)
+        final_tile = self.parent.map_size[0]*(self.y//self.parent.tilesize)+(self.x//self.parent.tilesize)
         if not init_tile == final_tile:
             self.parent.UpdateObj(init_tile,final_tile,self.id)
         
         # Check for ground state
-        leftfoottile = self.parent.map_size[0]*((self.y+(self.parent.tilesize/2)+1)/self.parent.tilesize)+((self.x-(self.parent.tilesize/2))/self.parent.tilesize)
-        rightfoottile = self.parent.map_size[0]*((self.y+(self.parent.tilesize/2)+1)/self.parent.tilesize)+((self.x+(self.parent.tilesize/2))/self.parent.tilesize)
+        leftfoottile = self.parent.map_size[0]*((self.y+(self.parent.tilesize//2)+1)//self.parent.tilesize)+((self.x-(self.parent.tilesize//2))//self.parent.tilesize)
+        rightfoottile = self.parent.map_size[0]*((self.y+(self.parent.tilesize//2)+1)//self.parent.tilesize)+((self.x+(self.parent.tilesize//2))//self.parent.tilesize)
         if self.parent.occlayer[leftfoottile] == 1 or self.parent.occlayer[rightfoottile] == 1 or ground_state_on_block or ground_state_on_platform:
             self.ground_state = True
             self.vx = 0
@@ -398,11 +398,11 @@
             self.ground_state = False
     
     def MoveBlock(self, objmovevec):
-        init_tile = self.parent.map_size[0]*(self.y/self.parent.tilesize)+(self.x/self.parent.tilesize)
+        init_tile = self.parent.map_size[0]*(self.y//self.parent.tilesize)+(self.x//self.parent.tilesize)
         vx = objmovevec[0]
         vy = objmovevec[1]
         (self.x,self.y) = self.parent.HandleObjectWallCollision((self.x+vx,self.y+vy),(self.parent.tilesize,self.parent.tilesize),(vx,vy))
-        final_tile = self.parent.map_size[0]*(self.y/self.parent.tilesize)+(self.x/self.parent.tilesize)
+        final_tile = self.parent.map_size[0]*(self.y//self.parent.tilesize)+(self.x//self.parent.tilesize)
         if not init_tile == final_tile:
             self.parent.UpdateObj(init_tile,final_tile,self.id)
         
@@ -412,9 +412,9 @@
             if id == self.id:
                 continue
             block = self.parent.movingblocks[id-100]
-            checkx1 = self.x+(ts/2) > (block.x-ts/2) and self.x+(ts/2) < (block.x+ts/2) and vx > 0
-            checkx2 = self.x-(ts/2) < (block.x+ts/2) and self.x-(ts/2) > (block.x-ts/2) and vx < 0
-            checky = self.y+(ts/2) > (block.y-ts/2) and self.y-(ts/2) < (block.y+ts/2)
+            checkx1 = self.x+(ts//2) > (block.x-ts//2) and self.x+(ts//2) < (block.x+ts//2) and vx > 0
+            checkx2 = self.x-(ts//2) < (block.x+ts//2) and self.x-(ts//2) > (block.x-ts//2) and vx < 0
+            checky = self.y+(ts//2) > (block.y-ts//2) and self.y-(ts//2) < (block.y+ts//2)
             if checkx1 and checky:
                 self.x = block.x - ts - 1
             elif checkx2 and checky:
@@ -424,9 +424,9 @@
         src_coords = resources.tiles_coords[19]
         self.sprite.source_rect.x = src_coords[0]
         self.sprite.source_rect.y = src_coords[1]
-        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view/2,self.parent.h_camera.y-self.parent.h_camera.h_view/2)
-        self.sprite.rect.x = int(self.x-(self.parent.tilesize/2)-camerax)
-        self.sprite.rect.y = int(self.y-(self.parent.tilesize/2)-cameray)
+        (camerax,cameray) = (self.parent.h_camera.x-self.parent.h_camera.w_view//2,self.parent.h_camera.y-self.parent.h_camera.h_view//2)
+        self.sprite.rect.x = int(self.x-(self.parent.tilesize//2)-camerax)
+        self.sprite.rect.y = int(self.y-(self.parent.tilesize//2)-cameray)
 
 class TiledLayers(object):
     
@@ -445,7 +445,7 @@
         self.tilelayer_mg = resources.initleveldata[level_id].tilelayer_mg[:]
         self.tilelayer_fg = resources.initleveldata[level_id].tilelayer_fg[:]
         self.occlayer = resources.initleveldata[level_id].occlayer[:]
-        self.objectlayer = [[] for i in xrange(self.map_size[0]*self.map_size[1])]
+        self.objectlayer = [[] for i in range(self.map_size[0]*self.map_size[1])]
         
         # Hack to colour scrolls on wall in level_computerroom
         if self.level_id == "level_computerroom":
@@ -490,13 +490,13 @@
         else:
             player_start_tile = self.exit_data[ingress_id][0]
         self.h_player.x = self.tilesize*(player_start_tile%self.map_size[0])+8
-        self.h_player.y = self.tilesize*(player_start_tile/self.map_size[0])-1
+        self.h_player.y = self.tilesize*(player_start_tile//self.map_size[0])-1
         self.InsertObj(player_start_tile,0)
         
         # Initialise moving blocks into map
         self.movingblocks = []
         self.movingblocks_spritegroup = pygame.sprite.LayeredDirty([])
-        for i in xrange(resources.initleveldata[level_id].movingblockdata[0]):
+        for i in range(resources.initleveldata[level_id].movingblockdata[0]):
             tile = resources.initleveldata[level_id].movingblockdata[i+1]
             id = 100+i
             self.movingblocks.append(MovingBlock(self,tile,id=id))
@@ -547,7 +547,7 @@
         
         # Initialise bats
         self.batgroup = killerbat.BatGroup(self,self.h_camera,self.h_player)
-        for i in xrange(resources.initleveldata[level_id].killerbatdata[0]):
+        for i in range(resources.initleveldata[level_id].killerbatdata[0]):
             tile = resources.initleveldata[level_id].killerbatdata[i+1]
             self.batgroup.AddBat(tile)
         
@@ -586,16 +586,16 @@
                     self.bglayer_tfg.blit(resources.tiles, (coords[0],coords[1]), area=tilecoords)
         
     def UpdateTileLayer(self, tile, tileval):
-        coords = [(tile%self.map_size[0])*self.tilesize, (tile/self.map_size[0])*self.tilesize]
+        coords = [(tile%self.map_size[0])*self.tilesize, (tile//self.map_size[0])*self.tilesize]
         if tileval >= 0:
             tilecoords = resources.tiles_coords[tileval]
             self.bglayer_t.blit(resources.tiles, (coords[0],coords[1]), area=tilecoords)
     
     def RenderMidLayer(self, screen):
-        screen.blit(self.bglayer_t, (0,0), area=(self.h_camera.x-self.h_camera.w_view/2, self.h_camera.y-self.h_camera.h_view/2, self.h_camera.w_view, self.h_camera.h_view))
+        screen.blit(self.bglayer_t, (0,0), area=(self.h_camera.x-self.h_camera.w_view//2, self.h_camera.y-self.h_camera.h_view//2, self.h_camera.w_view, self.h_camera.h_view))
     
     def RenderFGLayer(self, screen):
-        screen.blit(self.bglayer_tfg, (0,0), area=(self.h_camera.x-self.h_camera.w_view/2, self.h_camera.y-self.h_camera.h_view/2, self.h_camera.w_view, self.h_camera.h_view))
+        screen.blit(self.bglayer_tfg, (0,0), area=(self.h_camera.x-self.h_camera.w_view//2, self.h_camera.y-self.h_camera.h_view//2, self.h_camera.w_view, self.h_camera.h_view))
     
     def InsertObj(self,tileind,objid):
         self.objectlayer[tileind].append(objid)
@@ -690,31 +690,31 @@
         sy = objsize[1]
         ts = self.tilesize
         
-        tileocc_ul = self.map_size[0]*((y-(sy/2))/ts)+((x-(sx/2))/ts)
-        tileocc_ur = self.map_size[0]*((y-(sy/2))/ts)+((x+(sx/2))/ts)
-        tileocc_ll = self.map_size[0]*((y+(sy/2))/ts)+((x-(sx/2))/ts)
-        tileocc_lr = self.map_size[0]*((y+(sy/2))/ts)+((x+(sx/2))/ts)
-        
-        tileocc_u = self.map_size[0]*((y-(sy/2))/ts)+(x/ts)
-        tileocc_d = self.map_size[0]*((y+(sy/2))/ts)+(x/ts)
-        tileocc_l = self.map_size[0]*(y/ts)+((x-(sx/2))/ts)
-        tileocc_r = self.map_size[0]*(y/ts)+((x+(sx/2))/ts)
+        tileocc_ul = self.map_size[0]*((y-(sy//2))//ts)+((x-(sx//2))//ts)
+        tileocc_ur = self.map_size[0]*((y-(sy//2))//ts)+((x+(sx//2))//ts)
+        tileocc_ll = self.map_size[0]*((y+(sy//2))//ts)+((x-(sx//2))//ts)
+        tileocc_lr = self.map_size[0]*((y+(sy//2))//ts)+((x+(sx//2))//ts)
+        
+        tileocc_u = self.map_size[0]*((y-(sy//2))//ts)+(x//ts)
+        tileocc_d = self.map_size[0]*((y+(sy//2))//ts)+(x//ts)
+        tileocc_l = self.map_size[0]*(y//ts)+((x-(sx//2))//ts)
+        tileocc_r = self.map_size[0]*(y//ts)+((x+(sx//2))//ts)
         
         if vx > 0 and vy == 0: # handle lateral/longitudinal collisions
             if self.occlayer[tileocc_ur] or self.occlayer[tileocc_lr] or self.occlayer[tileocc_r]:
-                x = ts*(tileocc_ur % self.map_size[0]) - 1 - sx/2
+                x = ts*(tileocc_ur % self.map_size[0]) - 1 - sx//2
         elif vx < 0 and vy == 0:
             if self.occlayer[tileocc_ul] or self.occlayer[tileocc_ll] or self.occlayer[tileocc_l]:
-                x = ts*(tileocc_ul % self.map_size[0]) + 1 + sx/2 + ts
+                x = ts*(tileocc_ul % self.map_size[0]) + 1 + sx//2 + ts
         elif vx == 0 and vy > 0:
             if self.occlayer[tileocc_lr] or self.occlayer[tileocc_ll] or self.occlayer[tileocc_d]:
-                y = ts*(tileocc_ll/self.map_size[0]) - 1 - sy/2
+                y = ts*(tileocc_ll//self.map_size[0]) - 1 - sy//2
         elif vx == 0 and vy < 0:
             if self.occlayer[tileocc_ul] or self.occlayer[tileocc_ur] or self.occlayer[tileocc_u]:
-                y = ts*(tileocc_ul/self.map_size[0]) + 1 + sy/2 + ts
+                y = ts*(tileocc_ul//self.map_size[0]) + 1 + sy//2 + ts
         elif vx > 0 and vy < 0: # handle corner cases
-            xref = ts*(tileocc_ur % self.map_size[0]) - 1 - sx/2
-            yref = ts*(tileocc_ur/self.map_size[0]) + 1 + sy/2 + ts
+            xref = ts*(tileocc_ur % self.map_size[0]) - 1 - sx//2
+            yref = ts*(tileocc_ur//self.map_size[0]) + 1 + sy//2 + ts
             if self.occlayer[tileocc_ul] and self.occlayer[tileocc_lr]:
                 x = xref
                 y = yref
@@ -728,8 +728,8 @@
                 else:
                     y = yref
         elif vx > 0 and vy > 0:
-            xref = ts*(tileocc_lr % self.map_size[0]) - 1 - sx/2
-            yref = ts*(tileocc_lr/self.map_size[0]) - 1 - sy/2
+            xref = ts*(tileocc_lr % self.map_size[0]) - 1 - sx//2
+            yref = ts*(tileocc_lr//self.map_size[0]) - 1 - sy//2
             if self.occlayer[tileocc_ll] and self.occlayer[tileocc_ur]:
                 x = xref
                 y = yref
@@ -743,8 +743,8 @@
                 else:
                     y = yref
         elif vx < 0 and vy > 0:
-            xref = ts*(tileocc_ll % self.map_size[0]) + 1 + sx/2 + ts
-            yref = ts*(tileocc_ll/self.map_size[0]) - 1 - sy/2
+            xref = ts*(tileocc_ll % self.map_size[0]) + 1 + sx//2 + ts
+            yref = ts*(tileocc_ll//self.map_size[0]) - 1 - sy//2
             if self.occlayer[tileocc_ul] and self.occlayer[tileocc_lr]:
                 x = xref
                 y = yref
@@ -758,8 +758,8 @@
                 else:
                     y = yref
         elif vx < 0 and vy < 0:
-            xref = ts*(tileocc_ul % self.map_size[0]) + 1 + sx/2 + ts
-            yref = ts*(tileocc_ul/self.map_size[0]) + 1 + sy/2 + ts
+            xref = ts*(tileocc_ul % self.map_size[0]) + 1 + sx//2 + ts
+            yref = ts*(tileocc_ul//self.map_size[0]) + 1 + sy//2 + ts
             if self.occlayer[tileocc_ur] and self.occlayer[tileocc_ll]:
                 x = xref
                 y = yref
diff -ruN -x '*.png' a/src/wd_main.py b/src/wd_main.py
--- a/src/wd_main.py	1969-12-31 21:00:00.000000000 -0300
+++ b/src/wd_main.py	2026-11-04 23:19:11.717255417 -0300
@@ -0,0 +1,93 @@
+#!/usr/bin/python
+
+"""
+main.py - Main entry point for game
+"""
+
+import os
+import pygame
+from pygame.locals import *
+from gamedirector import *
+
+import resources
+import game
+import cutscenes
+
+# Start
+async def main(mainpath):
+    # on the web the page keeps the /saves folder in the browser
+    savefile = '/saves/saved_progress.txt' if os.path.isdir('/saves') else os.path.join(mainpath, 'data', 'saved_progress.txt')
+
+
+    # Initialise pygame
+    pygame.init()
+    pygame.mixer.init()
+    pygame.mouse.set_visible(False)
+    
+    # start up director
+    framerate = 30
+    #screen_res = (480,320)
+    screen_res = (320,240)
+    #screen_res = (192,128)
+    window_title = "Game"
+    dir = GameDirector(window_title, screen_res, framerate)
+    
+    # Load resources
+    resources.init(mainpath,screen_res)
+    
+    # Title Screen
+    titlescene = cutscenes.TitleScreen(dir, screen_res)
+    titlescene.savepath = savefile
+    dir.addscene('titlescene', titlescene)
+    
+    # Cutscens
+    logocutscene = cutscenes.CutScene(dir, screen_res)
+    dir.addscene('logocutscene', logocutscene)
+    
+    storycutscene = cutscenes.CutScene(dir, screen_res)
+    dir.addscene('storycutscene', storycutscene)
+    
+    gotscrollscene = cutscenes.GotScroll(dir, screen_res)
+    dir.addscene('gotscroll', gotscrollscene)
+    
+    wingamescene = cutscenes.CutScene(dir, screen_res)
+    dir.addscene('wingamescene', wingamescene)
+    
+    # Load game scenes
+    maingame = game.MainGame(dir, screen_res)
+    maingame.progress_data.savepath = savefile
+    titlescene.h_progress_data = maingame.progress_data
+    dir.addscene('maingame', maingame)
+    deathscene = game.Death(dir, screen_res)
+    dir.addscene('death', deathscene)
+    pausescene = game.PauseScreen(dir, screen_res)
+    dir.addscene('pausescene', pausescene)
+    maingame.h_pausescene = pausescene
+    
+    # start up director
+    #dir.change_scene('maingame', [True,"level_computerroom",-1])
+    #dir.change_scene('maingame', [True,"level_dragonroom",-1])
+    
+    #dir.change_scene('maingame', [True,"level_basicmechanisms",-1])
+    #dir.change_scene('maingame', [True,"level_basiclava",-1])
+    #dir.change_scene('maingame', [True,"level_theroundabout",-1])
+    #dir.change_scene('maingame', [True,"level_basicelectric",-1])
+    #dir.change_scene('maingame', [True,"level_thelift",-1])
+    
+    #dir.change_scene('maingame', [True,"level_getscroll_blue",-1])
+    #dir.change_scene('maingame', [True,"level_getscroll_green",-1])
+    #dir.change_scene('maingame', [True,"level_getscroll_red",-1])
+    
+    #dir.change_scene('titlescene', [])
+    dir.change_scene('logocutscene', resources.logocutscene_data)
+    #dir.change_scene('storycutscene', resources.storycutscene_data)
+    #dir.change_scene('wingamescene', resources.wingamescene_data)
+    
+    #dir.change_scene('gotscroll', ["scroll_red"])
+    await dir.loop()
+    
+    # exiting, record framerate
+    #fp = open(os.path.join(mainpath,'framerate.txt'),"w")
+    #fp.write("%f\n"%(maingame.avgframerate))
+    #fp.close()
+