427 lines
11 KiB
Python
Executable File
427 lines
11 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
global cpt
|
|
global Origcpt
|
|
global EmuMod
|
|
global RomCpt
|
|
global MaxRomCpt
|
|
global CurentEmu
|
|
|
|
FirstRun = 1
|
|
cpt = 0
|
|
RomCpt =0
|
|
import configparser
|
|
from collections import Counter
|
|
from tkinter import *
|
|
from tkinter import ttk
|
|
from PIL import Image, ImageTk
|
|
import PIL.Image
|
|
import PIL.ImageTk
|
|
import sys
|
|
from modules.arrow import *
|
|
from modules.emulateur_display import *
|
|
import time
|
|
import os
|
|
#sys.path.append( './modules/')
|
|
#from arrow import *
|
|
|
|
|
|
#EmuMod :
|
|
# 0 : Emu select
|
|
# 1 : Rom select
|
|
|
|
|
|
|
|
#def EmuMod():
|
|
|
|
|
|
|
|
def ViewRom(EmuName,RomCpt):
|
|
|
|
print("Canevas ROM MEDIA : " + str(Cnv.find_all()))
|
|
|
|
for IdCanvas in Cnv.find_all():
|
|
if IdCanvas != 1:
|
|
Cnv.delete(IdCanvas)
|
|
BackgroundRom(str(CurentEmu))
|
|
print("DEBUG MAX ROM: " + str(MaxRomCpt))
|
|
|
|
WheelEmu="./data/roms/"+str(EmuName)+"/media/wheel/" + str(EmuName) + "_wheel.png"
|
|
IsWheelEmu = IsFileExist(WheelEmu,"wheelemu")
|
|
OpenWheelEmu=Image.open(IsWheelEmu)
|
|
ResizeOpenWheelEmu=OpenWheelEmu.resize((RomUpSquareSizeX,RomUpSquareSizeY))
|
|
TkOpenWheelEmu=ImageTk.PhotoImage(ResizeOpenWheelEmu)
|
|
LabelResizeOpenWheelEmu=Label(arkadeus, image=TkOpenWheelEmu)
|
|
LabelResizeOpenWheelEmu.TkOpenWheelEmu = TkOpenWheelEmu
|
|
|
|
Wheel="./data/roms/"+str(EmuName)+"/media/wheel/" + str(RomRes[RomCpt]) + ".png"
|
|
print("Wheel : "+ Wheel)
|
|
IsWheel = IsFileExist(Wheel,"wheelemu")
|
|
OpenWheel=Image.open(IsWheel)
|
|
ResizeOpenWheel=OpenWheel.resize((RomMiddleSquareSizeX,RomMiddleSquareSizeY))
|
|
TkOpenWheel=ImageTk.PhotoImage(ResizeOpenWheel)
|
|
LabelResizeOpenWheel=Label(arkadeus, image=TkOpenWheel)
|
|
LabelResizeOpenWheel.TkOpenWheel = TkOpenWheel
|
|
|
|
Wheel="./data/roms/"+str(EmuName)+"/media/wheel/" + str(RomRes[RomCpt]) + ".png"
|
|
IsWheel = IsFileExist(Wheel,"wheelemu")
|
|
OpenWheel=Image.open(IsWheel)
|
|
ResizeOpenWheel=OpenWheel.resize((RomBottomSquareSizeX,RomBottomSquareSizeY))
|
|
TkOpenWheel=ImageTk.PhotoImage(ResizeOpenWheel)
|
|
LabelResizeOpenWheel=Label(arkadeus, image=TkOpenWheel)
|
|
LabelResizeOpenWheel.TkOpenWheel = TkOpenWheel
|
|
|
|
Text="./data/roms/"+str(EmuName)+"/media/doc/" + str(RomRes[RomCpt]) + ".txt"
|
|
IsText = IsFileExist(Text,"doc")
|
|
with open(IsText, 'rb') as RomFile:
|
|
DataRomFile = RomFile.read().rstrip()
|
|
|
|
SnapEmu="./data/roms/"+str(EmuName)+"/media/snap/" + str(RomRes[RomCpt]) + ".png"
|
|
IsSnapEmu = IsFileExist(SnapEmu,"snap")
|
|
OpenSnapEmu=Image.open(IsSnapEmu)
|
|
ResizeOpenSnapEmu=OpenSnapEmu.resize((RomLeftSquareSizeX,RomLeftSquareSizeY))
|
|
TkOpenSnapEmu=ImageTk.PhotoImage(ResizeOpenSnapEmu)
|
|
LabelResizeOpenSnapEmu=Label(arkadeus, image=TkOpenSnapEmu)
|
|
LabelResizeOpenSnapEmu.TkOpenSnapEmu = TkOpenSnapEmu
|
|
|
|
BoxText=Cnv.create_text(RomBottomSquareX,RomBottomSquareY,width= RomBottomSquareSizeX, text=DataRomFile,fill="white",font="Times 20 bold")
|
|
BoxRect=Cnv.create_rectangle(RomBottomSquareTxtUpX,RomBottomSquareTxtUpY,RomBottomSquareTxtBottomX,RomBottomSquareTxtBottomY ,fill='black')
|
|
Cnv.tag_lower(BoxRect,BoxText)
|
|
Cnv.create_image(RomUpSquareX, RomUpSquareY, image=TkOpenWheelEmu)
|
|
Cnv.create_image(RomMiddleSquareX, RomMiddleSquareY, image=TkOpenWheel)
|
|
#Cnv.create_image(RomBottomSquareX, RomBottomSquareY, image=TkOpenWheel)
|
|
Cnv.create_image(RomLeftSquareX, RomLeftSquareY, image=TkOpenSnapEmu)
|
|
|
|
Cnv.pack(fill = "both", expand = True)
|
|
|
|
|
|
def BackgroundRom(Emu):
|
|
|
|
|
|
print("Canevas ROM : " + str(Cnv.find_all()))
|
|
|
|
|
|
|
|
EmuBgFile = "./data/emu/media/" + str(Emu) +"_bg.png"
|
|
EmuBgFile = IsFileExist(EmuBgFile,"bg")
|
|
|
|
OpenEmuBgfile=Image.open(EmuBgFile)
|
|
PhotoEmuBgFile=OpenEmuBgfile.resize((Xsize,Ysize))
|
|
TkPhotoEmuBgFile=ImageTk.PhotoImage(PhotoEmuBgFile)
|
|
LabelEmuBgFile=Label(arkadeus, image=TkPhotoEmuBgFile)
|
|
LabelEmuBgFile.TkPhotoEmuBgFile = TkPhotoEmuBgFile
|
|
Cnv.create_image(0, 0, image=TkPhotoEmuBgFile, anchor = "nw")
|
|
|
|
|
|
def IsFileExist(AbsPathFile,TypeMedia):
|
|
if not os.path.exists(AbsPathFile):
|
|
match TypeMedia:
|
|
case "emu":
|
|
return "./media/noemu.png"
|
|
case "bg":
|
|
return "./media/nobg.png"
|
|
case "wheel":
|
|
return "./media/nowheel.png"
|
|
case "snap":
|
|
return "./media/nosnap.png"
|
|
case "wheelemu":
|
|
return "./media/nowheelemu.png"
|
|
case "doc":
|
|
return "./media/nodoc.txt"
|
|
else:
|
|
return AbsPathFile
|
|
|
|
def BackgroundEmu():
|
|
|
|
BackgroundEmu = Media["background"]
|
|
BgEmu = PhotoImage(file = Background)
|
|
LabelBgEmu = Label(arkadeus,image=BgEmu)
|
|
LabelBgEmu.BgEmu = BgEmu
|
|
Cnv.create_image( 0, 0, image = BgEmu, anchor = "nw")
|
|
|
|
def EnterEmu(GetEmuMod):
|
|
global EmuMod
|
|
global cpt
|
|
global RomCpt
|
|
RomCpt=0
|
|
if GetEmuMod == 0:
|
|
RomCpt = 1
|
|
EmuMod = 1
|
|
print("Emu : " + str(CurentEmu))
|
|
#Cnv.delete("all")
|
|
#BackgroundRom(str(CurentEmu))
|
|
GenRomListPerGame(str(CurentEmu))
|
|
|
|
|
|
#if RomCpt > MaxRomCpt:
|
|
# RomCpt = 0
|
|
print("ENTER MODE : " + str(EmuRes[RomCpt]) + " ID :" + str(RomCpt))
|
|
ViewRom(CurentEmu,RomCpt)
|
|
|
|
|
|
def ViewEmu(cL,xL,yL,cM,xM,yM,cR,xR,yR):
|
|
NfL="./data/emu/media/" + EmuRes[cL] + ".png"
|
|
NfL = IsFileExist(NfL,"emu")
|
|
NfM="./data/emu/media/" + EmuRes[cM] + ".png"
|
|
NfM = IsFileExist(NfM,"emu")
|
|
NfR="./data/emu/media/" + EmuRes[cR] + ".png"
|
|
NfR = IsFileExist(NfR,"emu")
|
|
|
|
|
|
OpenNfL=Image.open(NfL)
|
|
PhotoNfL=OpenNfL.resize((Square,Square))
|
|
TkNfL=ImageTk.PhotoImage(PhotoNfL)
|
|
LabelPNfL=Label(arkadeus, image=TkNfL)
|
|
LabelPNfL.TkNfL = TkNfL
|
|
|
|
OpenNfM=Image.open(NfM)
|
|
PhotoNfM=OpenNfM.resize((Square,Square))
|
|
TkNfM=ImageTk.PhotoImage(PhotoNfM)
|
|
LabelPNfM=Label(arkadeus, image=TkNfM)
|
|
LabelPNfM.TkNfM = TkNfM
|
|
|
|
OpenNfR=Image.open(NfR)
|
|
PhotoNfR=OpenNfR.resize((Square,Square))
|
|
TkNfR=ImageTk.PhotoImage(PhotoNfR)
|
|
LabelPNfR=Label(arkadeus, image=TkNfR)
|
|
LabelPNfR.TkNfR = TkNfR
|
|
|
|
Cnv.pack(fill = "both", expand = True)
|
|
for IdCanvas in Cnv.find_all():
|
|
if IdCanvas != 1:
|
|
Cnv.delete(IdCanvas)
|
|
|
|
print (str(xL) + ":" + str(yL))
|
|
Cnv.create_image(xL, yL, image=TkNfL)
|
|
Cnv.create_image(xM, yM, image=TkNfM)
|
|
Cnv.create_image(xR, yR, image=TkNfR)
|
|
print("Curent Emu : " + str(EmuRes[cM]))
|
|
|
|
def leftKey(GetEmuMod):
|
|
if GetEmuMod == 0:
|
|
global CurentEmu
|
|
global cpt
|
|
cpt = cpt - 1
|
|
if cpt < 0:
|
|
cpt = EmuCpt
|
|
Lcpt = cpt
|
|
Mcpt = cpt + 1
|
|
Rcpt = cpt + 2
|
|
if Mcpt > EmuCpt:
|
|
Mcpt = 0
|
|
Rcpt = 1
|
|
if Rcpt > EmuCpt:
|
|
Rcpt = 0
|
|
print("DEBUG : " + str(EmuMod) + " Emu : " + str(cpt))
|
|
CurentEmu = EmuRes[Mcpt]
|
|
ViewEmu(Lcpt,EmuLeftSquareX, EmuLeftSquareY,Mcpt,EmuMiddleSquareX, EmuMiddleSquareY,Rcpt,EmuRightSquareX, EmuRightSquareY)
|
|
if GetEmuMod == 1:
|
|
global RomCpt
|
|
RomCpt=RomCpt - 1
|
|
if RomCpt < 0:
|
|
RomCpt = MaxRomCpt
|
|
print("Running - : " + str(RomCpt) + " ROM : " + str(RomRes[RomCpt]))
|
|
ViewRom(CurentEmu,RomCpt)
|
|
|
|
def rightKey(GetEmuMod):
|
|
|
|
if GetEmuMod == 0:
|
|
global CurentEmu
|
|
global cpt
|
|
cpt = cpt + 1
|
|
if cpt > EmuCpt:
|
|
cpt = 0
|
|
Lcpt = cpt
|
|
Mcpt = cpt + 1
|
|
Rcpt = cpt + 2
|
|
if Mcpt > EmuCpt:
|
|
Mcpt = 0
|
|
Rcpt = 1
|
|
if Rcpt > EmuCpt:
|
|
Rcpt = 0
|
|
print("DEBUG : " + str(EmuMod) + " Emu : " + str(cpt))
|
|
ViewEmu(Lcpt,EmuLeftSquareX, EmuLeftSquareY,Mcpt,EmuMiddleSquareX, EmuMiddleSquareY,Rcpt,EmuRightSquareX, EmuRightSquareY)
|
|
CurentEmu = EmuRes[Mcpt]
|
|
if GetEmuMod == 1:
|
|
global RomCpt
|
|
RomCpt=RomCpt + 1
|
|
if RomCpt > MaxRomCpt:
|
|
RomCpt = 0
|
|
print("Running + : " + str(RomCpt) + " ROM : " + str(RomRes[RomCpt]))
|
|
|
|
ViewRom(CurentEmu,RomCpt)
|
|
|
|
|
|
def Escape(GetEmuMod):
|
|
if GetEmuMod == 0:
|
|
print("Ciao !!")
|
|
arkadeus.quit()
|
|
if GetEmuMod == 1:
|
|
global EmuMod
|
|
global cpt
|
|
EmuMod = 0
|
|
cpt = 0
|
|
|
|
|
|
BackgroundEmu()
|
|
ViewEmu(0,EmuLeftSquareX, EmuLeftSquareY,1,EmuMiddleSquareX, EmuMiddleSquareY,2,EmuRightSquareX, EmuRightSquareY)
|
|
|
|
|
|
|
|
def GenEmuList():
|
|
global EmuRes
|
|
dir_path = r'./data/emu/bin/'
|
|
for path in os.listdir(dir_path):
|
|
if os.path.isfile(os.path.join(dir_path, path)):
|
|
FileName=os.path.splitext(path)[0]
|
|
EmuRes.append(FileName)
|
|
print("DEBUG : " + FileName)
|
|
|
|
cnt = Counter(EmuRes)
|
|
global EmuCpt
|
|
EmuCpt=len(cnt) - 1
|
|
print(" Nmbre emulateur : " + str(EmuCpt))
|
|
|
|
|
|
def GenRomListPerGame(Emu):
|
|
global RomRes
|
|
RomRes.clear()
|
|
print("DEBUG Gen List ROM : " + str(Emu))
|
|
DirRomPath='./data/roms/'+Emu+'/roms'
|
|
dir_rom_path = r''+DirRomPath
|
|
|
|
isDirRom = os.path.isdir(DirRomPath)
|
|
print ("Dir : " + DirRomPath + " : status:" + str(isDirRom))
|
|
if isDirRom == True:
|
|
|
|
for RomFile in os.listdir(dir_rom_path):
|
|
if os.path.isfile(os.path.join(dir_rom_path, RomFile)):
|
|
RomFileName=os.path.splitext(RomFile)[0]
|
|
RomRes.append(RomFileName)
|
|
print("DEBUG : " + RomFileName)
|
|
|
|
cntrom = Counter(RomRes)
|
|
global RomCpt
|
|
global MaxRomCpt
|
|
MaxRomCpt=len(cntrom) - 1
|
|
print("Nmbre de roms : " + str(MaxRomCpt))
|
|
print ("ListROms : " + str(RomRes))
|
|
print ("TEST 1942 : " + str(RomRes[0]) )
|
|
|
|
|
|
arkadeus= Tk()
|
|
|
|
global EmuRes
|
|
global RomRes
|
|
|
|
EmuRes = []
|
|
RomRes = []
|
|
|
|
EmuMod = 0
|
|
|
|
GenEmuList()
|
|
|
|
config_obj = configparser.ConfigParser()
|
|
config_obj.read("./conf/config.ini")
|
|
Media = config_obj["Media"]
|
|
ForceRes = Media["force_resolution"]
|
|
Background = Media["background"]
|
|
Square = int(Media["square_size"])
|
|
|
|
config_rom = configparser.ConfigParser()
|
|
config_rom.read("./conf/games.ini")
|
|
|
|
Emulateur = config_rom["emulateurs"]
|
|
|
|
print(Emulateur["EmulateurList"])
|
|
IdEmu(Emulateur["EmulateurList"])
|
|
|
|
|
|
arkadeus.attributes('-fullscreen', True)
|
|
arkadeus.title("Arkadeus")
|
|
|
|
|
|
|
|
if ForceRes == "y":
|
|
Xsize = int(Media["x_resolution"])
|
|
Ysize = int(Media["y_resolution"])
|
|
else:
|
|
Xsize = arkadeus.winfo_screenwidth()
|
|
Ysize = arkadeus.winfo_screenheight()
|
|
|
|
|
|
################ Carto Emu Mode ####################
|
|
EmuMiddleSquareX=(Xsize/2)
|
|
EmuMiddleSquareY=(Ysize/2)
|
|
|
|
EmuLeftSquareX=(Xsize/3)
|
|
EmuLeftSquareY=(Ysize/3)
|
|
|
|
EmuRightSquareX=(Xsize*2/3)
|
|
EmuRightSquareY=(Ysize/3)
|
|
|
|
################ Carto Rom Mode ####################
|
|
|
|
RomIndice = 40
|
|
|
|
#RomIndiceX = round(Xsize / RomIndice)
|
|
#RomIndiceY = round(Ysize / RomIndice)
|
|
|
|
RomIndiceX = RomIndice
|
|
RomIndiceY = RomIndice
|
|
|
|
RomUpSquareX=RomIndiceX
|
|
RomUpSquareY=RomIndiceY
|
|
|
|
RomUpSquareSizeX=round(((Xsize-(RomIndiceX*3))/2))
|
|
RomUpSquareSizeY=round(((Ysize-(RomIndiceY*4))/3))
|
|
RomUpSquareX=round(RomIndiceX + RomUpSquareSizeX/2)
|
|
RomUpSquareY=round(RomIndiceY + RomUpSquareSizeY/2)
|
|
|
|
RomMiddleSquareSizeX=RomUpSquareSizeX
|
|
RomMiddleSquareSizeY=RomUpSquareSizeY
|
|
RomMiddleSquareX=RomUpSquareX
|
|
RomMiddleSquareY=RomUpSquareY*2 + RomUpSquareSizeY/2
|
|
|
|
RomBottomSquareSizeX=RomUpSquareSizeX
|
|
RomBottomSquareSizeY=RomUpSquareSizeY
|
|
RomBottomSquareX=RomUpSquareX
|
|
RomBottomSquareY=RomUpSquareY*3 + RomUpSquareSizeY
|
|
|
|
RomBottomSquareTxtUpX=RomIndiceX
|
|
RomBottomSquareTxtUpY= RomIndiceY*3+RomUpSquareSizeY*2
|
|
|
|
RomBottomSquareTxtBottomX=RomBottomSquareTxtUpX + RomBottomSquareSizeX
|
|
RomBottomSquareTxtBottomY=RomBottomSquareTxtUpY +RomUpSquareSizeY
|
|
|
|
|
|
RomLeftSquareSizeX=RomUpSquareSizeX - RomIndiceX
|
|
RomLeftSquareSizeY=round((Ysize-(RomIndiceY*2)))
|
|
RomLeftSquareX=RomIndiceX+ RomLeftSquareSizeX/2 + Xsize/2
|
|
RomLeftSquareY=round(RomIndiceY + RomLeftSquareSizeY/2)
|
|
|
|
####################################################
|
|
|
|
|
|
|
|
|
|
|
|
Cnv = Canvas( arkadeus, width = Ysize , height = Xsize)
|
|
Cnv.pack(fill = "both", expand = True)
|
|
|
|
if EmuMod == 0:
|
|
BackgroundEmu()
|
|
ViewEmu(cpt,EmuLeftSquareX, EmuLeftSquareY,cpt+1,EmuMiddleSquareX, EmuMiddleSquareY,cpt+2,EmuRightSquareX, EmuRightSquareY)
|
|
|
|
if EmuMod == 1:
|
|
ViewEmu(cpt,EmuLeftSquareX, EmuLeftSquareY,cpt+1,EmuMiddleSquareX, EmuMiddleSquareY,cpt+2,EmuRightSquareX, EmuRightSquareY)
|
|
|
|
|
|
|
|
arkadeus.bind("<Left>", lambda event: leftKey(EmuMod))
|
|
arkadeus.bind("<Right>", lambda event: rightKey(EmuMod))
|
|
arkadeus.bind("<Return>", lambda event: EnterEmu(EmuMod))
|
|
arkadeus.bind('<Escape>',lambda event : Escape(EmuMod))
|
|
|
|
arkadeus.mainloop()
|