diff -ruN a/main.py b/main.py
--- a/main.py	1969-12-31 21:00:00.000000000 -0300
+++ b/main.py	2026-11-04 23:07:37.221254613 -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 adrift_main
+
+asyncio.run(adrift_main.main(mainpath))
diff -ruN a/run_game.py b/run_game.py
--- a/run_game.py	2026-11-04 23:05:40.950937080 -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 template for director-scene 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 a/src/adrift_main.py b/src/adrift_main.py
--- a/src/adrift_main.py	1969-12-31 21:00:00.000000000 -0300
+++ b/src/adrift_main.py	2026-11-04 23:07:37.220474614 -0300
@@ -0,0 +1,126 @@
+#!/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
+from common import CutScene, CutSceneShipExplode
+
+# Start
+async def main(mainpath):
+
+    # Initialise pygame
+    pygame.init()
+    pygame.mixer.init()
+    pygame.mouse.set_visible(False)
+    
+    # start up director
+    framerate = 30
+    screen_res = (640,480)
+    window_title = "Game"
+    dir = GameDirector(window_title, screen_res, framerate)
+    
+    # Load resources
+    resources.init(mainpath)
+    
+    # Load game scenes
+    logocutscene = CutScene(dir, screen_res)
+    dir.addscene('logocutscene', logocutscene)
+    
+    quotescene = CutScene(dir, screen_res)
+    dir.addscene('quotescene', quotescene)
+    
+    # on the web the page keeps the /saves folder in the browser
+    savepath = '/saves/saved_progress.txt' if os.path.isdir('/saves') else os.path.join(mainpath,'data','saved_progress.txt')
+    titlescreen = game.TitleScreen(dir, screen_res, 0, savepath)
+    dir.addscene('titlescreen', titlescreen)
+    
+    pausegame = game.PauseGame(dir, screen_res, 128)
+    dir.addscene('pausegame', pausegame)
+    
+    maingame = game.MainGame(dir, screen_res)
+    maingame.h_pausescene = pausegame
+    dir.addscene('maingame', maingame)
+    maingame.trackingdata.savepath = savepath
+    titlescreen.h_maingame = maingame
+    
+    summaryscreen = game.SummaryScreen(dir, screen_res, 0)
+    dir.addscene('summaryscreen', summaryscreen)
+    
+    # major cut scenes:
+    
+    # prologue:
+    prologuescene1 = CutScene(dir, screen_res)
+    dir.addscene('prologuescene1', prologuescene1)
+    prologuescene2 = CutScene(dir, screen_res)
+    dir.addscene('prologuescene2', prologuescene2)
+    prologuescene3 = CutScene(dir, screen_res)
+    dir.addscene('prologuescene3', prologuescene3)
+    prologuescene4 = CutScene(dir, screen_res)
+    dir.addscene('prologuescene4', prologuescene4)
+    
+    chapter1scene1 = CutScene(dir, screen_res)
+    dir.addscene('chapter1scene1', chapter1scene1)
+    chapter1scene2 = CutScene(dir, screen_res)
+    dir.addscene('chapter1scene2', chapter1scene2)
+    chapter1scene3 = CutSceneShipExplode(dir, screen_res)
+    dir.addscene('chapter1scene3', chapter1scene3)
+    
+    chapter2scene1 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene1', chapter2scene1)
+    chapter2scene2 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene2', chapter2scene2)
+    chapter2scene3 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene3', chapter2scene3)
+    chapter2scene4 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene4', chapter2scene4)
+    chapter2scene5 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene5', chapter2scene5)
+    chapter2scene6 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene6', chapter2scene6)
+    chapter2scene7 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene7', chapter2scene7)
+    chapter2scene8 = CutScene(dir, screen_res)
+    dir.addscene('chapter2scene8', chapter2scene8)
+    
+    chapter3scene1 = CutScene(dir, screen_res)
+    dir.addscene('chapter3scene1', chapter3scene1)
+    chapter3scene2 = CutScene(dir, screen_res)
+    dir.addscene('chapter3scene2', chapter3scene2)
+    chapter3scene3 = CutScene(dir, screen_res)
+    dir.addscene('chapter3scene3', chapter3scene3)
+    chapter3scene4 = CutScene(dir, screen_res)
+    dir.addscene('chapter3scene4', chapter3scene4)
+    
+    chapter4scene1 = CutScene(dir, screen_res)
+    dir.addscene('chapter4scene1', chapter4scene1)
+    chapter4scene2 = CutScene(dir, screen_res)
+    dir.addscene('chapter4scene2', chapter4scene2)
+    chapter4scene3 = CutScene(dir, screen_res)
+    dir.addscene('chapter4scene3', chapter4scene3)
+    
+    chapter5scene1 = CutScene(dir, screen_res)
+    dir.addscene('chapter5scene1', chapter5scene1)
+    chapter5scene2 = CutScene(dir, screen_res)
+    dir.addscene('chapter5scene2', chapter5scene2)
+    chapter5scene3 = CutScene(dir, screen_res)
+    dir.addscene('chapter5scene3', chapter5scene3)
+    
+    # start up director
+    dir.change_scene('logocutscene', resources.logocutscene_data)
+    #dir.change_scene('chapter3scene1', resources.chap3_1_data)
+    #dir.change_scene('titlescreen', [])
+    #dir.change_scene('maingame', [True, 'level_twosections'])
+    #dir.change_scene('summaryscreen', [[5,7,1,20], 'level_default2'])
+    await dir.loop()
+    
+    #print "Avg. framerate: %f"%(maingame.avgframerate)
+
+
diff -ruN a/src/common.py b/src/common.py
--- a/src/common.py	2026-11-04 23:05:40.977159458 -0300
+++ b/src/common.py	2026-11-04 23:07:37.161254787 -0300
@@ -44,17 +44,17 @@
     
     def constrain(self):
         hit = False
-        if self.x < self.w_view/2:
-            self.x = self.w_view/2
+        if self.x < self.w_view//2:
+            self.x = self.w_view//2
             hit = True
-        elif self.x > (self.xlim-self.w_view/2):
-            self.x = self.xlim-self.w_view/2
+        elif self.x > (self.xlim-self.w_view//2):
+            self.x = self.xlim-self.w_view//2
             hit = True
-        if self.y < self.h_view/2:
-            self.y = self.h_view/2
+        if self.y < self.h_view//2:
+            self.y = self.h_view//2
             hit = True
-        elif self.y > (self.ylim-self.h_view/2):
-            self.y = self.ylim-self.h_view/2
+        elif self.y > (self.ylim-self.h_view//2):
+            self.y = self.ylim-self.h_view//2
             hit = True
         return hit
     
@@ -161,7 +161,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:
@@ -170,7 +170,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))))
     
@@ -323,7 +323,7 @@
         self.menulist.Draw(screen)
         self.SetMousePos()
         tilecoords = resources.mouse_spritesheet_coords['hover'][resources.mouse_spriteseq['hover'][0]]
-        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize/2,self.cursor_pos_screen[1]-self.cursorsize/2), area=tilecoords)
+        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize//2,self.cursor_pos_screen[1]-self.cursorsize//2), area=tilecoords)
 
 class CutScene(GameScene):
     def __init__(self, director, window_size):
@@ -429,13 +429,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)
     
@@ -485,15 +485,15 @@
         self.render_bg(screen)
         if self.textstep >= 0:
             self.render_text(screen)
-        radius_a = self.timer/4
-        radius_b = self.timer/8
+        radius_a = self.timer//4
+        radius_b = self.timer//8
         if self.timer < 140:
             radius2 = 0
         else:
-            radius2 = (self.timer-140)/2
+            radius2 = (self.timer-140)//2
         pygame.draw.ellipse(screen, (208,208,208), ((320-radius_a,240-radius_b),(2*radius_a,2*radius_b)))
         if radius2 > 0:
-            pygame.draw.ellipse(screen, (0,0,0), ((320-radius2,240-(radius2/2)),(2*radius2,radius2)))
+            pygame.draw.ellipse(screen, (0,0,0), ((320-radius2,240-(radius2//2)),(2*radius2,radius2)))
         self.fadebackground.set_alpha(self.fade.alpha)
         screen.blit(self.fadebackground, (0, 0))
     
diff -ruN a/src/game.py b/src/game.py
--- a/src/game.py	2026-11-04 23:05:40.976705875 -0300
+++ b/src/game.py	2026-11-04 23:07:37.158247083 -0300
@@ -52,7 +52,7 @@
         if self.crewescapepod > 0:
             screen.blit(resources.hud_data['panel_launch'], resources.hud_data['panel_launch_coords'])
             pygame.draw.rect(screen,resources.hud_data['launchcolours'][self.frame],((171*3+22,10*3+415),(29*3-2,10*3-2)),3)
-        for i in xrange(len(self.parent.unitlist)):
+        for i in range(len(self.parent.unitlist)):
             id = self.parent.unitlist[i].charid
             if self.parent.unitlist[i].type == 'unit':
                 surfref = resources.hud_data['panel_facesunits'][id]
@@ -203,13 +203,13 @@
             msx = self.parent.h_tiledlayers.map_size[0]
             for h in self.assoc_tiles:
                 x = (h%msx)*ts
-                y = (h/msx)*ts
-                assocpos = (x-self.parent.h_camera.x+self.parent.h_camera.w_view/2,y-self.parent.h_camera.y+self.parent.h_camera.h_view/2)
+                y = (h//msx)*ts
+                assocpos = (x-self.parent.h_camera.x+self.parent.h_camera.w_view//2,y-self.parent.h_camera.y+self.parent.h_camera.h_view//2)
                 pygame.draw.rect(screen,(0,255,0),(assocpos,(ts,ts)),3)
-            x = (self.tile%msx)*ts + (ts/2) - 80
-            y = (self.tile/msx)*ts + (ts/2) - 24
+            x = (self.tile%msx)*ts + (ts//2) - 80
+            y = (self.tile//msx)*ts + (ts//2) - 24
             screen.blit(resources.assist_message[self.msgkey], \
-                (x-self.parent.h_camera.x+self.parent.h_camera.w_view/2,y-self.parent.h_camera.y+self.parent.h_camera.h_view/2))
+                (x-self.parent.h_camera.x+self.parent.h_camera.w_view//2,y-self.parent.h_camera.y+self.parent.h_camera.h_view//2))
 
 class KeyControl():
     
@@ -227,8 +227,8 @@
     
     def SetMousePos(self):
         self.cursor_pos_screen = pygame.mouse.get_pos()
-        self.cursor_pos = (int(self.cursor_pos_screen[0]+self.h_camera.x-self.h_camera.w_view/2), \
-            int(self.cursor_pos_screen[1]+self.h_camera.y-self.h_camera.h_view/2))
+        self.cursor_pos = (int(self.cursor_pos_screen[0]+self.h_camera.x-self.h_camera.w_view//2), \
+            int(self.cursor_pos_screen[1]+self.h_camera.y-self.h_camera.h_view//2))
     
     def ProcessKeyEvent(self,event):
         if event.type == KEYDOWN and event.key == K_z: # debug create new unit
@@ -236,7 +236,7 @@
             self.h_unitlist.append(units.MouseControlableUnit(len(self.h_unitlist),'unit'))
             self.h_unitlist[-1].set_handles((self.h_camera, self.h_tiledlayers))
             tsize = self.h_tiledlayers.tilesize
-            gtile = self.h_tiledlayers.map_size[0]*(self.cursor_pos[1]/tsize)+(self.cursor_pos[0]/tsize)
+            gtile = self.h_tiledlayers.map_size[0]*(self.cursor_pos[1]//tsize)+(self.cursor_pos[0]//tsize)
             self.h_unitlist[-1].SetTile(gtile)
             self.h_tiledlayers.InsertObj(gtile,self.h_unitlist[-1].id)
         elif event.type == KEYUP:
@@ -244,7 +244,7 @@
         elif event.type == MOUSEMOTION:
             self.SetMousePos()
             tsize = self.h_tiledlayers.tilesize
-            tile = self.h_tiledlayers.map_size[0]*(self.cursor_pos[1]/tsize)+(self.cursor_pos[0]/tsize)
+            tile = self.h_tiledlayers.map_size[0]*(self.cursor_pos[1]//tsize)+(self.cursor_pos[0]//tsize)
             self.assistmsg.Update(tile)
         elif event.type == MOUSEBUTTONDOWN:
             if self.parent.msgdialogue.mentor == True:
@@ -263,7 +263,7 @@
             if self.parent.gamestate == 'playing':
                 self.SetMousePos()
                 tsize = self.h_tiledlayers.tilesize
-                gtile = self.h_tiledlayers.map_size[0]*(self.cursor_pos[1]/tsize)+(self.cursor_pos[0]/tsize)
+                gtile = self.h_tiledlayers.map_size[0]*(self.cursor_pos[1]//tsize)+(self.cursor_pos[0]//tsize)
                 # first check if launching escape pod
                 if self.parent.hud.crewescapepod > 0:
                     rect = ((171*3+22,10*3+415),(29*3-2,10*3-2))
@@ -304,7 +304,7 @@
                                         else:
                                             unit = self.h_unitlist[self.unit_id]
                                             unit.task = [] # reset task for now
-                                            ptile = self.h_tiledlayers.map_size[0]*(unit.y/tsize)+(unit.x/tsize)
+                                            ptile = self.h_tiledlayers.map_size[0]*(unit.y//tsize)+(unit.x//tsize)
                                             switch_stand_tile = self.h_tiledlayers.switchcontrol.switches[switch_ids[0]].tile2
                                             unit.path = self.h_planner.astar_path(ptile, switch_stand_tile)
                                             if unit.path == []:
@@ -318,7 +318,7 @@
                             elif self.unit_id >= 0: # directing a unit somewhere, not a switch
                                 unit = self.h_unitlist[self.unit_id]
                                 unit.task = [] # reset task for now
-                                ptile = self.h_tiledlayers.map_size[0]*(unit.y/tsize)+(unit.x/tsize)
+                                ptile = self.h_tiledlayers.map_size[0]*(unit.y//tsize)+(unit.x//tsize)
                                 unit.path = self.h_planner.astar_path(ptile, gtile)
                                 if unit.path == []:
                                     self.parent.msgdialogue.DisplayMsg("unitnomove")
@@ -331,12 +331,12 @@
             x = self.h_unitlist[self.unit_id].x
             y = self.h_unitlist[self.unit_id].y
             ts = self.h_unitlist[self.unit_id].tilesize
-            unitpos = (x-(ts/2)-self.h_camera.x+self.h_camera.w_view/2-6,y-(ts/2)-self.h_camera.y+self.h_camera.h_view/2-6)
+            unitpos = (x-(ts//2)-self.h_camera.x+self.h_camera.w_view//2-6,y-(ts//2)-self.h_camera.y+self.h_camera.h_view//2-6)
             pygame.draw.rect(screen,(255,0,0),(unitpos,(ts+12,ts+12)),3)
             
     def DrawCursor(self,screen):
         tilecoords = resources.mouse_spritesheet_coords['hover'][resources.mouse_spriteseq['hover'][0]]
-        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize/2,self.cursor_pos_screen[1]-self.cursorsize/2), area=tilecoords)
+        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize//2,self.cursor_pos_screen[1]-self.cursorsize//2), area=tilecoords)
 
 class TrackingData(object):
     def __init__(self):
@@ -405,11 +405,11 @@
         # re-draw stars randomly
         self.starrybackdrop = pygame.Surface(self.window_size)
         self.starrybackdrop.fill((0,0,0))
-        for i in xrange(35):
+        for i in range(35):
             x = random.randint(-5,634)
             y = random.randint(-5,474)
             self.starrybackdrop.blit(resources.singlestar, (x,y), area=(9,0,9,9))
-        for i in xrange(10):
+        for i in range(10):
             x = random.randint(-5,634)
             y = random.randint(-5,474)
             self.starrybackdrop.blit(resources.singlestar, (x,y), area=(0,0,9,9))
@@ -656,7 +656,7 @@
         elif self.timer > 150:
             alpha = 255
         else:
-            alpha = (255/60)*(self.timer-90)
+            alpha = (255//60)*(self.timer-90)
         self.menulist.buttons[0].surf_on.set_alpha(alpha)
         self.menulist.buttons[0].surf_off.set_alpha(alpha)
         if len(self.menulist.buttons) > 1:
@@ -665,7 +665,7 @@
         self.menulist.Draw(screen)
         self.SetMousePos()
         tilecoords = resources.mouse_spritesheet_coords['hover'][resources.mouse_spriteseq['hover'][0]]
-        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize/2,self.cursor_pos_screen[1]-self.cursorsize/2), area=tilecoords)
+        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize//2,self.cursor_pos_screen[1]-self.cursorsize//2), area=tilecoords)
         
 
 class SummaryScreen(ClickOptionsScreen):    
@@ -731,6 +731,6 @@
         self.menulist.Draw(screen)
         self.SetMousePos()
         tilecoords = resources.mouse_spritesheet_coords['hover'][resources.mouse_spriteseq['hover'][0]]
-        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize/2,self.cursor_pos_screen[1]-self.cursorsize/2), area=tilecoords)
+        screen.blit(resources.mouse_spritesheet, (self.cursor_pos_screen[0]-self.cursorsize//2,self.cursor_pos_screen[1]-self.cursorsize//2), area=tilecoords)
 
     
diff -ruN a/src/gamedirector.py b/src/gamedirector.py
--- a/src/gamedirector.py	2026-11-04 23:05:40.974484712 -0300
+++ b/src/gamedirector.py	2026-11-04 23:07:37.219514324 -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 *
 
@@ -19,9 +21,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
@@ -48,8 +55,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.display.flip()
     
@@ -58,7 +65,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 a/src/main.py b/src/main.py
--- a/src/main.py	2026-11-04 23:05:40.978422289 -0300
+++ b/src/main.py	1969-12-31 21:00:00.000000000 -0300
@@ -1,125 +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
-from common import CutScene, CutSceneShipExplode
-
-# Start
-def main(mainpath):
-
-    # Initialise pygame
-    pygame.init()
-    pygame.mixer.init()
-    pygame.mouse.set_visible(False)
-    
-    # start up director
-    framerate = 30
-    screen_res = (640,480)
-    window_title = "Game"
-    dir = GameDirector(window_title, screen_res, framerate)
-    
-    # Load resources
-    resources.init(mainpath)
-    
-    # Load game scenes
-    logocutscene = CutScene(dir, screen_res)
-    dir.addscene('logocutscene', logocutscene)
-    
-    quotescene = CutScene(dir, screen_res)
-    dir.addscene('quotescene', quotescene)
-    
-    savepath = os.path.join(mainpath,'data','saved_progress.txt')
-    titlescreen = game.TitleScreen(dir, screen_res, 0, savepath)
-    dir.addscene('titlescreen', titlescreen)
-    
-    pausegame = game.PauseGame(dir, screen_res, 128)
-    dir.addscene('pausegame', pausegame)
-    
-    maingame = game.MainGame(dir, screen_res)
-    maingame.h_pausescene = pausegame
-    dir.addscene('maingame', maingame)
-    maingame.trackingdata.savepath = os.path.join(mainpath,'data','saved_progress.txt')
-    titlescreen.h_maingame = maingame
-    
-    summaryscreen = game.SummaryScreen(dir, screen_res, 0)
-    dir.addscene('summaryscreen', summaryscreen)
-    
-    # major cut scenes:
-    
-    # prologue:
-    prologuescene1 = CutScene(dir, screen_res)
-    dir.addscene('prologuescene1', prologuescene1)
-    prologuescene2 = CutScene(dir, screen_res)
-    dir.addscene('prologuescene2', prologuescene2)
-    prologuescene3 = CutScene(dir, screen_res)
-    dir.addscene('prologuescene3', prologuescene3)
-    prologuescene4 = CutScene(dir, screen_res)
-    dir.addscene('prologuescene4', prologuescene4)
-    
-    chapter1scene1 = CutScene(dir, screen_res)
-    dir.addscene('chapter1scene1', chapter1scene1)
-    chapter1scene2 = CutScene(dir, screen_res)
-    dir.addscene('chapter1scene2', chapter1scene2)
-    chapter1scene3 = CutSceneShipExplode(dir, screen_res)
-    dir.addscene('chapter1scene3', chapter1scene3)
-    
-    chapter2scene1 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene1', chapter2scene1)
-    chapter2scene2 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene2', chapter2scene2)
-    chapter2scene3 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene3', chapter2scene3)
-    chapter2scene4 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene4', chapter2scene4)
-    chapter2scene5 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene5', chapter2scene5)
-    chapter2scene6 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene6', chapter2scene6)
-    chapter2scene7 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene7', chapter2scene7)
-    chapter2scene8 = CutScene(dir, screen_res)
-    dir.addscene('chapter2scene8', chapter2scene8)
-    
-    chapter3scene1 = CutScene(dir, screen_res)
-    dir.addscene('chapter3scene1', chapter3scene1)
-    chapter3scene2 = CutScene(dir, screen_res)
-    dir.addscene('chapter3scene2', chapter3scene2)
-    chapter3scene3 = CutScene(dir, screen_res)
-    dir.addscene('chapter3scene3', chapter3scene3)
-    chapter3scene4 = CutScene(dir, screen_res)
-    dir.addscene('chapter3scene4', chapter3scene4)
-    
-    chapter4scene1 = CutScene(dir, screen_res)
-    dir.addscene('chapter4scene1', chapter4scene1)
-    chapter4scene2 = CutScene(dir, screen_res)
-    dir.addscene('chapter4scene2', chapter4scene2)
-    chapter4scene3 = CutScene(dir, screen_res)
-    dir.addscene('chapter4scene3', chapter4scene3)
-    
-    chapter5scene1 = CutScene(dir, screen_res)
-    dir.addscene('chapter5scene1', chapter5scene1)
-    chapter5scene2 = CutScene(dir, screen_res)
-    dir.addscene('chapter5scene2', chapter5scene2)
-    chapter5scene3 = CutScene(dir, screen_res)
-    dir.addscene('chapter5scene3', chapter5scene3)
-    
-    # start up director
-    dir.change_scene('logocutscene', resources.logocutscene_data)
-    #dir.change_scene('chapter3scene1', resources.chap3_1_data)
-    #dir.change_scene('titlescreen', [])
-    #dir.change_scene('maingame', [True, 'level_twosections'])
-    #dir.change_scene('summaryscreen', [[5,7,1,20], 'level_default2'])
-    dir.loop()
-    
-    #print "Avg. framerate: %f"%(maingame.avgframerate)
-
-
diff -ruN a/src/menuscenes.py b/src/menuscenes.py
--- a/src/menuscenes.py	2026-11-04 23:05:40.979543746 -0300
+++ b/src/menuscenes.py	2026-11-04 23:07:37.179694176 -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 a/src/path.py b/src/path.py
--- a/src/path.py	2026-11-04 23:05:40.979020497 -0300
+++ b/src/path.py	2026-11-04 23:08:37.856103965 -0300
@@ -12,7 +12,7 @@
 import resources
 from math import *
 import heapq
-import Queue
+import queue
 
 class Planner(object):
     def __init__(self,mapsize,tilesize,occlayer):
@@ -21,14 +21,14 @@
         self.tilesize = tilesize
         self.h_occlayer = occlayer
         self.pn = 0
-        self.touched = [0 for i in xrange(self.w*self.h)]
-        self.cost_so_far = [0 for i in xrange(self.w*self.h)]
-        self.came_from = [0 for i in xrange(self.w*self.h)]
+        self.touched = [0 for i in range(self.w*self.h)]
+        self.cost_so_far = [0 for i in range(self.w*self.h)]
+        self.came_from = [0 for i in range(self.w*self.h)]
     
     def getneighbours(self, i):
         neighbours = []
         x = i%self.w
-        y = i/self.w
+        y = i//self.w
         cost = 1
         costd = sqrt(2)
         if x > 0 and not self.h_occlayer[i-1]:
@@ -51,9 +51,9 @@
     
     def heuristic(self,i,j):
         xi = i%self.w
-        yi = i/self.w
+        yi = i//self.w
         xj = j%self.w
-        yj = j/self.w
+        yj = j//self.w
         return abs(xi - xj) + abs(yi - yj)
     
     def astar_path(self, start, goal):
@@ -102,7 +102,7 @@
     
     def UpdateVacuumCells(self,start,val,max_volume):
         self.pn += 1
-        frontier = Queue.Queue()
+        frontier = queue.Queue()
         self.touched[start] = self.pn
         self.h_airlayer[start] = val
         frontier.put(start)
@@ -130,7 +130,7 @@
                     self.UpdateVacuumCells(dt,0,-1)
     """
     def UpdateVacuum(self,doortiles): # new vacuum function: re-fills air when no long exposed to space
-        for i in xrange(len(self.h_airlayer)):
+        for i in range(len(self.h_airlayer)):
             self.h_airlayer[i] = 1
         for vs in self.h_vacsources:
             self.UpdateVacuumCells(vs[0],0,-1)
diff -ruN a/src/resources.py b/src/resources.py
--- a/src/resources.py	2026-11-04 23:05:40.977550207 -0300
+++ b/src/resources.py	2026-11-04 23:07:37.166865528 -0300
@@ -16,44 +16,44 @@
         self.map_size = [int(i) for i in f.readline().split()]
         self.music = f.readline().split()[0]
         self.tilelayer = []
-        for j in xrange(self.map_size[1]):
+        for j in range(self.map_size[1]):
             self.tilelayer.extend([int(i) for i in f.readline().split()])
         #self.tilelayer_bg = []
-        #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()])
         #self.tilelayer_fg = []
-        #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()])
         self.occlayer = []
-        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.goaltiles = [int(i) for i in f.readline().split()]
         self.firetiles = [int(i) for i in f.readline().split()]
         self.powerpacktiles = [int(i) for i in f.readline().split()]
         numitems = [int(i) for i in f.readline().split()][0]
         self.vacsources = []
-        for j in xrange(numitems):
+        for j in range(numitems):
             self.vacsources.append([int(i) for i in f.readline().split()])
         numitems = [int(i) for i in f.readline().split()][0]
         self.units = []
-        for j in xrange(numitems):
+        for j in range(numitems):
             data = f.readline().split()
             self.units.append([int(data[0]),data[1],int(data[2])])
         self.switches = []
         num = [int(i) for i in f.readline().split()][0]
-        for i in xrange(num):
+        for i in range(num):
             data = f.readline().split()
             self.switches.append([int(data[0]), int(data[1]), data[2], data[3], int(data[4])])
-            for j in xrange(len(data)-5):
+            for j in range(len(data)-5):
                 self.switches[-1].append(int(data[j+5]))
         self.doors = []
         num = [int(i) for i in f.readline().split()][0]
-        for i in xrange(num):
+        for i in range(num):
             data = f.readline().split()
             self.doors.append([int(data[0]), int(data[1]), int(data[2])])
         self.vacpumps = []
         num = [int(i) for i in f.readline().split()][0]
-        for i in xrange(num):
+        for i in range(num):
             data = f.readline().split()
             self.vacpumps.append([int(data[0]), int(data[1]), int(data[2])])
         f.close()
@@ -65,12 +65,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))
@@ -78,7 +78,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 = []
@@ -90,7 +90,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
@@ -98,10 +98,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(' '):
@@ -136,8 +136,8 @@
     tiles = pygame.image.load(os.path.join(mainpath,'data','gfx','tilesheet_3x.png')).convert()
     tiles.set_colorkey((0,0,0))
     tiles_coords = []
-    for j in xrange(36):
-        for i in xrange(8):
+    for j in range(36):
+        for i in range(8):
             tiles_coords.append((i*27+3, j*27+3, 24, 24))
     
     # generate lookups for determining dark/light rendering according to vacuum (per tile! god this is annoying)
@@ -215,14 +215,14 @@
     player_spritesheet['floating'].set_colorkey((0,0,0))
     
     player_spritesheet_coords = []
-    for j in xrange(5):
-        for i in xrange(8):
+    for j in range(5):
+        for i in range(8):
             player_spritesheet_coords.append((i*30+3, j*33+3, 27, 27))
     
     tempsurf = pygame.image.load(os.path.join(mainpath,'data','gfx','units_3x.png')).convert()
     angles = [180,90,0,270]
     for j in [0,1,3]:
-        for i in xrange(8):
+        for i in range(8):
             coords = (i*30+3, j*33+3, 27, 27)
             coords2 = (i*30+3, 2*33+3, 27, 27)
             tempsurf2 = pygame.Surface((27,27))
@@ -230,7 +230,7 @@
             tempsurf3 = pygame.transform.rotate(tempsurf2,angles[j])
             player_spritesheet['floating'].blit(tempsurf3, (coords[0],coords[1]))
     for j in [0,1,3,4]:
-        for i in xrange(8):
+        for i in range(8):
             coords = (i*30+3, j*33+3, 27, 27)
             tempsurf2 = pygame.Surface((27,27))
             tempsurf2.blit(tempsurf, (0,0), area=coords)
@@ -259,7 +259,7 @@
     mouse_spritesheet.set_colorkey((255,0,255))
     mouse_spritesheet_coords = {}
     mouse_spritesheet_coords['hover'] = []
-    for i in xrange(4):
+    for i in range(4):
         mouse_spritesheet_coords['hover'].append((i*24, 0, 24, 24))
     mouse_spriteseq = {}
     mouse_spriteseq['hover'] = [0]
@@ -403,13 +403,13 @@
     hud_data['panel_statusbox_coords'] = (2*3,10*3)
     
     hud_data['panel_facesunits'] = []
-    for i in xrange(8):
+    for i in range(8):
         hud_data['panel_facesunits'].append(pygame.Surface((8*3,8*3)))
         hud_data['panel_facesunits'][-1].set_colorkey((0,0,0))
         hud_data['panel_facesunits'][-1].convert()
         hud_data['panel_facesunits'][-1].blit(hud_data['panel_surf'], (0,0), area=(126*3+i*8*3,54*3,8*3,8*3))
     hud_data['panel_facesastro'] = []
-    for i in xrange(4):
+    for i in range(4):
         hud_data['panel_facesastro'].append(pygame.Surface((8*3,8*3)))
         hud_data['panel_facesastro'][-1].set_colorkey((0,0,0))
         hud_data['panel_facesastro'][-1].convert()
@@ -595,7 +595,7 @@
         self.starposy2 = []
         self.starsize2 = []
         self.starN = 25
-        for i in xrange(self.starN):
+        for i in range(self.starN):
             self.starposx1.append(random.randint(-5,634))
             self.starposy1.append(random.randint(-5,474))
             val = random.randint(0,3)
@@ -603,7 +603,7 @@
                 self.starsize1.append('big')
             else:
                 self.starsize1.append('small')
-        for i in xrange(self.starN):
+        for i in range(self.starN):
             self.starposx2.append(random.randint(-5,634))
             self.starposy2.append(random.randint(-5,474))
             val = random.randint(0,3)
@@ -613,7 +613,7 @@
                 self.starsize2.append('small')
     
     def Update(self):
-        for i in xrange(self.starN):
+        for i in range(self.starN):
             self.starposx1[i] += 2
             if self.starposx1[i] > 640:
                 self.starposx1[i] = 0
@@ -624,12 +624,12 @@
                 self.starposy2[i] = random.randint(-5,474)
     
     def Draw(self, screen):
-        for i in xrange(self.starN):
+        for i in range(self.starN):
             if self.starsize1[i] == 'big':
                 screen.blit(singlestar, (self.starposx1[i],self.starposy1[i]), area=(0,0,9,9))
             else:
                 screen.blit(singlestar, (self.starposx1[i],self.starposy1[i]), area=(9,0,9,9))
-        for i in xrange(self.starN):
+        for i in range(self.starN):
             if self.starsize2[i] == 'big':
                 screen.blit(singlestar, (self.starposx2[i],self.starposy2[i]), area=(0,0,9,9))
             else:
diff -ruN a/src/tilemap.py b/src/tilemap.py
--- a/src/tilemap.py	2026-11-04 23:05:40.976126126 -0300
+++ b/src/tilemap.py	2026-11-04 23:07:37.152808174 -0300
@@ -77,9 +77,9 @@
             self.switches[-1].orient = 3
     
     def DrawSwitches(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 s in self.switches:
-            coords = [(s.tile1%self.parent.map_size[0])*self.parent.tilesize, (s.tile1/self.parent.map_size[0])*self.parent.tilesize]
+            coords = [(s.tile1%self.parent.map_size[0])*self.parent.tilesize, (s.tile1//self.parent.map_size[0])*self.parent.tilesize]
             if s.type == 'powerplug':
                 if s.state >= 0:
                     tileval = resources.switches_tiles[s.mode][0]+s.orient
@@ -111,13 +111,13 @@
         mint = min(tile1,tile2)
         maxt = max(tile1,tile2)
         mapsizex = self.h_tiledlayers.map_size[0]
-        if (mint/mapsizex) == (maxt/mapsizex): # on same row, horizontal door
+        if (mint//mapsizex) == (maxt//mapsizex): # on same row, horizontal door
             self.direction = 'horizontal'
-            for i in xrange(mint+1,maxt):
+            for i in range(mint+1,maxt):
                 self.tilelist.append(i)
         else:
             self.direction = 'vertical'
-            for i in xrange(mint+mapsizex,maxt,mapsizex):
+            for i in range(mint+mapsizex,maxt,mapsizex):
                 self.tilelist.append(i)
             
         #self.nframes = 4
@@ -169,7 +169,7 @@
             """
     
     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:
@@ -182,11 +182,11 @@
                     tileval += 4
                 tilecoords = resources.tiles_coords[tileval]
                 x1 = ts*(t%msx)
-                y1 = ts*(t/msx)
+                y1 = ts*(t//msx)
                 screen.blit(resources.tiles, (x1-camerax,y1-cameray), area=tilecoords)
     
     def DrawDoorFrames(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:
@@ -196,7 +196,7 @@
                     tileval += 4
                 tilecoords = resources.tiles_coords[tileval]
                 x1 = ts*(t%msx)
-                y1 = ts*(t/msx)
+                y1 = ts*(t//msx)
                 screen.blit(resources.tiles, (x1-camerax,y1-cameray), area=tilecoords)
 
 class VacPump(object):
@@ -226,7 +226,7 @@
         self.parent.InsertObj(tile1,id)
     
     def DrawVacPumps(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 p in self.vacpumps:
@@ -235,14 +235,14 @@
             elif p.state == False:
                 tilecoords = resources.tiles_coords[resources.vacpump_tiles[1]]
             x1 = ts*(p.tile1%msx)
-            y1 = ts*(p.tile1/msx)
+            y1 = ts*(p.tile1//msx)
             screen.blit(resources.tiles, (x1-camerax,y1-cameray), area=tilecoords)
 
 class FireControl(object):
     def __init__(self,firetiles,parent):
         self.parent = parent
         self.firetiles = firetiles[:]
-        for i in xrange(len(self.firetiles)):
+        for i in range(len(self.firetiles)):
             self.parent.InsertObj(self.firetiles[i],i+200)
         self.nframes = 4
         self.ticks = 0
@@ -250,7 +250,7 @@
         self.frame = 0
     
     def UpdateFires(self):
-        for i in xrange(len(self.firetiles)):
+        for i in range(len(self.firetiles)):
             ft = self.firetiles[i]
             if ft == -1:
                 continue
@@ -262,31 +262,31 @@
         self.ticks += 1
     
     def DrawFires(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 i in xrange(len(self.firetiles)):
+        for i in range(len(self.firetiles)):
             ft = self.firetiles[i]
             if ft == -1:
                 continue
             frame = (self.frame+i)%self.nframes
             tilecoords = resources.tiles_coords[resources.fire_tiles[frame]]
             x1 = ts*(ft%msx)
-            y1 = ts*(ft/msx)
+            y1 = ts*(ft//msx)
             screen.blit(resources.tiles, (x1-camerax,y1-cameray), area=tilecoords)
 
 class PowerPackControl(object):
     def __init__(self,powerpacktiles,parent):
         self.parent = parent
         self.powerpacktiles = powerpacktiles[:]
-        for i in xrange(len(self.powerpacktiles)):
+        for i in range(len(self.powerpacktiles)):
             self.parent.InsertObj(self.powerpacktiles[i],i+700)
     
     def DrawPowerPacks(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 i in xrange(len(self.powerpacktiles)):
+        for i in range(len(self.powerpacktiles)):
             ppt = self.powerpacktiles[i]
             if ppt == -1:
                 continue
@@ -294,7 +294,7 @@
             #tilecoords = resources.tiles_coords[resources.powerpack_tiles[frame]]
             tilecoords = resources.tiles_coords[resources.powerpack_tile]
             x1 = ts*(ppt%msx)
-            y1 = ts*(ppt/msx)
+            y1 = ts*(ppt//msx)
             screen.blit(resources.tiles, (x1-camerax,y1-cameray), area=tilecoords)
 
 class EscapePod(object):
@@ -305,7 +305,7 @@
         self.speed = 2
         self.x = self.parent.tilesize*(tile%self.parent.map_size[0])
         self.relx = 0
-        self.y = self.parent.tilesize*(tile/self.parent.map_size[0] - 4)
+        self.y = self.parent.tilesize*(tile//self.parent.map_size[0] - 4)
         self.surf = pygame.Surface((24*7,24*9))
         self.surf.fill((0,0,0))
         self.surf.convert()
@@ -318,7 +318,7 @@
             self.relx += self.speed
     
     def Draw(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)
         screen.blit(self.surf, (self.x-camerax,self.y-cameray))
 
 class TiledLayers(object):
@@ -337,11 +337,11 @@
         self.tilelayer = resources.initleveldata[level_id].tilelayer[:]
         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])]
         
         # Special mentor messages in tilemap
         if level_id == "level_tutorial":
-            for i in xrange(len(resources.mentor_messages['tiles'])):
+            for i in range(len(resources.mentor_messages['tiles'])):
                 t = resources.mentor_messages['tiles'][i]
                 msgs = resources.mentor_messages['msg'][i]
                 self.InsertObj(t,i+800)
@@ -355,7 +355,7 @@
         self.h_camera.ylim = self.map_size[1]*self.tilesize
         
         # Initialise units data and load into object layer
-        for i in xrange(len(resources.initleveldata[level_id].units)):
+        for i in range(len(resources.initleveldata[level_id].units)):
             unit = resources.initleveldata[level_id].units[i]
             self.h_unitlist.append(units.MouseControlableUnit(i,unit[1],unit[2]))
             self.h_unitlist[-1].set_handles((self.h_camera, self, self.parent.msgdialogue, self.h_control))
@@ -374,7 +374,7 @@
         self.vacsources = []
         for v in resources.initleveldata[level_id].vacsources:
             self.vacsources.append(v[:])
-        self.airlayer = [1 for i in xrange(self.map_size[0]*self.map_size[1])]
+        self.airlayer = [1 for i in range(self.map_size[0]*self.map_size[1])]
         self.vacuumcontroller = path.VacuumController(self.map_size,self.tilesize,self.occlayer,self.airlayer,self.vacsources)
         self.gfxairlayer = pygame.Surface((self.tilesize*self.map_size[0],self.tilesize*self.map_size[1]))
         self.gfxairlayer.fill((0,0,0))
@@ -418,7 +418,7 @@
         eb = resources.initleveldata[level_id].goaltiles[0]
         msx = self.map_size[0]
         self.goaltiles = [eb+2-msx,eb+3-msx,eb+4-msx,eb+5-msx,eb+2,eb+3,eb+4,eb+5,eb+2+msx,eb+3+msx,eb+4+msx,eb+5+msx]
-        for i in xrange(len(self.goaltiles)):
+        for i in range(len(self.goaltiles)):
             self.InsertObj(self.goaltiles[i],i+100)
         
         # escape pod
@@ -440,13 +440,13 @@
         self.ReRenderAirLayer()
         
     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 RenderTileLayer(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 ReRenderAirLayer(self):
         msx = self.map_size[0]
@@ -475,15 +475,15 @@
                 if self.airlayer[t+msx] == 0 and self.airlayer[t-msx] == 0: # trapped air inside closed door, covered by vacuum
                     tileval = self.tilelayer[t-1]+4
                     tilecoords = resources.tiles_coords[tileval]
-                    coords = [((t-1)%msx)*self.tilesize, ((t-1)/msx)*self.tilesize]
+                    coords = [((t-1)%msx)*self.tilesize, ((t-1)//msx)*self.tilesize]
                     self.bglayer_t.blit(resources.tiles, (coords[0],coords[1]), area=tilecoords)
                     tileval = self.tilelayer[t+1]+4
                     tilecoords = resources.tiles_coords[tileval]
-                    coords = [((t+1)%msx)*self.tilesize, ((t+1)/msx)*self.tilesize]
+                    coords = [((t+1)%msx)*self.tilesize, ((t+1)//msx)*self.tilesize]
                     self.bglayer_t.blit(resources.tiles, (coords[0],coords[1]), area=tilecoords)
     
     def RenderAirLayer(self, screen):
-        screen.blit(self.gfxairlayer, (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.gfxairlayer, (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)
diff -ruN a/src/units.py b/src/units.py
--- a/src/units.py	2026-11-04 23:05:40.975587835 -0300
+++ b/src/units.py	2026-11-04 23:07:37.148684639 -0300
@@ -44,8 +44,8 @@
         (self.h_camera, self.h_tiledlayers, self.h_msgdialogue, self.h_control) = handles
     
     def SetTile(self, tile):
-        self.x = self.tilesize*(tile%self.h_tiledlayers.map_size[0]) + self.tilesize/2
-        self.y = self.tilesize*(tile/self.h_tiledlayers.map_size[0]) + self.tilesize/2
+        self.x = self.tilesize*(tile%self.h_tiledlayers.map_size[0]) + self.tilesize//2
+        self.y = self.tilesize*(tile//self.h_tiledlayers.map_size[0]) + self.tilesize//2
     
     def Killed(self, cause):
         self.alive = False
@@ -53,7 +53,7 @@
         self.task = []
         tsize = self.h_tiledlayers.tilesize
         mapw = self.h_tiledlayers.map_size[0]
-        tile = mapw*(self.y/tsize)+(self.x/tsize)
+        tile = mapw*(self.y//tsize)+(self.x//tsize)
         if self.id == self.h_control.unit_id:
             self.h_control.unit_id = -1 # unselect
         if cause == 'fire':
@@ -81,12 +81,12 @@
         
         tsize = self.h_tiledlayers.tilesize
         mapw = self.h_tiledlayers.map_size[0]
-        init_tile = self.h_tiledlayers.map_size[0]*(self.y/tsize)+(self.x/tsize)
+        init_tile = self.h_tiledlayers.map_size[0]*(self.y//tsize)+(self.x//tsize)
         
         # check for achieved waypoint
         if len(self.path) > 0:
-            xdest = tsize*(self.path[0]%mapw) + tsize/2
-            ydest = tsize*(self.path[0]/mapw) + tsize/2
+            xdest = tsize*(self.path[0]%mapw) + tsize//2
+            ydest = tsize*(self.path[0]//mapw) + tsize//2
             if (xdest-self.x) == 0 and (ydest-self.y) == 0:
                 tile_achieved = self.path.pop(0)
                 if len(self.path) > 0: # still moving
@@ -95,8 +95,8 @@
                         self.path = []
                         self.task = []
                     else:
-                        xdest = tsize*(self.path[0]%mapw) + tsize/2
-                        ydest = tsize*(self.path[0]/mapw) + tsize/2
+                        xdest = tsize*(self.path[0]%mapw) + tsize//2
+                        ydest = tsize*(self.path[0]//mapw) + tsize//2
                 else: # just finished current path, check for tasks
                     if self.alive == False:
                         self.floataway = True
@@ -140,11 +140,11 @@
                                 self.numpowerpacks -= 1
                                 self.h_msgdialogue.DisplayMsg("powerplugactivate")
             if abs(xdest-self.x) > 0:
-                vx = (xdest-self.x)/abs(xdest-self.x)
+                vx = (xdest-self.x)//abs(xdest-self.x)
             else:
                 vx = 0
             if abs(ydest-self.y) > 0:
-                vy = (ydest-self.y)/abs(ydest-self.y)
+                vy = (ydest-self.y)//abs(ydest-self.y)
             else:
                 vy = 0
             if self.floataway == True:
@@ -178,7 +178,7 @@
         
         # Check if need to inform tilemap object layer of updates
         if self.alive == True:
-            final_tile = self.h_tiledlayers.map_size[0]*(self.y/tsize)+(self.x/tsize)
+            final_tile = self.h_tiledlayers.map_size[0]*(self.y//tsize)+(self.x//tsize)
             if not init_tile == final_tile and final_tile >=0 and \
                 final_tile < self.h_tiledlayers.map_size[0]*self.h_tiledlayers.map_size[1]:
                 self.h_tiledlayers.UpdateObj(init_tile,final_tile,self.id)
@@ -250,8 +250,8 @@
         tsize = self.h_tiledlayers.tilesize
         mapw = self.h_tiledlayers.map_size[0]
         for p in self.path[1:]:
-            x = tsize*(p%mapw) + 9 - self.h_camera.x + self.h_camera.w_view/2
-            y = tsize*(p/mapw) + 9 - self.h_camera.y + self.h_camera.h_view/2
+            x = tsize*(p%mapw) + 9 - self.h_camera.x + self.h_camera.w_view//2
+            y = tsize*(p//mapw) + 9 - self.h_camera.y + self.h_camera.h_view//2
             pygame.draw.rect(screen,(255,255,255),((x,y),(6,6)))
     
     def Draw(self,screen,drawtoescapepod=False):
@@ -272,7 +272,7 @@
             tilecoords = resources.player_spritesheet_coords[resources.player_spriteseq[self.type][self.gaittype][self.gait]+self.charid]
             renderfrom = resources.player_spritesheet['left']
         
-        screen.blit(renderfrom, (xrender-(self.tilesize/2)-self.h_camera.x+self.h_camera.w_view/2,self.y-(self.tilesize/2)-self.h_camera.y+self.h_camera.h_view/2 - 3), area=tilecoords)
+        screen.blit(renderfrom, (xrender-(self.tilesize//2)-self.h_camera.x+self.h_camera.w_view//2,self.y-(self.tilesize//2)-self.h_camera.y+self.h_camera.h_view//2 - 3), area=tilecoords)
         
         if self.alive == True:
             self.DrawPath(screen)