1# Copyright (c) 2013-2016 Jeffrey Pfau
  2#
  3# This Source Code Form is subject to the terms of the Mozilla Public
  4# License, v. 2.0. If a copy of the MPL was not distributed with this
  5# file, You can obtain one at http://mozilla.org/MPL/2.0/.
  6from ._pylib import ffi, lib
  7from . import tile, createCallback
  8from cached_property import cached_property
  9
 10def find(path):
 11    core = lib.mCoreFind(path.encode('UTF-8'))
 12    if core == ffi.NULL:
 13        return None
 14    return Core._init(core)
 15
 16def findVF(vf):
 17    core = lib.mCoreFindVF(vf.handle)
 18    if core == ffi.NULL:
 19        return None
 20    return Core._init(core)
 21
 22def loadPath(path):
 23    core = find(path)
 24    if not core or not core.loadFile(path):
 25        return None
 26    return core
 27
 28def loadVF(vf):
 29    core = findVF(vf)
 30    if not core or not core.loadROM(vf):
 31        return None
 32    return core
 33
 34def needsReset(f):
 35    def wrapper(self, *args, **kwargs):
 36        if not self._wasReset:
 37            raise RuntimeError("Core must be reset first")
 38        return f(self, *args, **kwargs)
 39    return wrapper
 40
 41def protected(f):
 42    def wrapper(self, *args, **kwargs):
 43        if self._protected:
 44            raise RuntimeError("Core is protected")
 45        return f(self, *args, **kwargs)
 46    return wrapper
 47
 48@ffi.def_extern()
 49def _mCorePythonCallbacksVideoFrameStarted(user):
 50    context = ffi.from_handle(user)
 51    context._videoFrameStarted()
 52
 53@ffi.def_extern()
 54def _mCorePythonCallbacksVideoFrameEnded(user):
 55    context = ffi.from_handle(user)
 56    context._videoFrameEnded()
 57
 58@ffi.def_extern()
 59def _mCorePythonCallbacksCoreCrashed(user):
 60    context = ffi.from_handle(user)
 61    context._coreCrashed()
 62
 63@ffi.def_extern()
 64def _mCorePythonCallbacksSleep(user):
 65    context = ffi.from_handle(user)
 66    context._sleep()
 67
 68class CoreCallbacks(object):
 69    def __init__(self):
 70        self._handle = ffi.new_handle(self)
 71        self.videoFrameStarted = []
 72        self.videoFrameEnded = []
 73        self.coreCrashed = []
 74        self.sleep = []
 75        self.context = lib.mCorePythonCallbackCreate(self._handle)
 76
 77    def _videoFrameStarted(self):
 78        for cb in self.videoFrameStarted:
 79            cb()
 80
 81    def _videoFrameEnded(self):
 82        for cb in self.videoFrameEnded:
 83            cb()
 84
 85    def _coreCrashed(self):
 86        for cb in self.coreCrashed:
 87            cb()
 88
 89    def _sleep(self):
 90        for cb in self.sleep:
 91            cb()
 92
 93class Core(object):
 94    if hasattr(lib, 'PLATFORM_GBA'):
 95        PLATFORM_GBA = lib.PLATFORM_GBA
 96
 97    if hasattr(lib, 'PLATFORM_GB'):
 98        PLATFORM_GB = lib.PLATFORM_GB
 99
100    def __init__(self, native):
101        self._core = native
102        self._wasReset = False
103        self._protected = False
104        self._callbacks = CoreCallbacks()
105        self._core.addCoreCallbacks(self._core, self._callbacks.context)
106        self.config = Config(ffi.addressof(native.config))
107
108    def __del__(self):
109        self._wasReset = False
110
111    @cached_property
112    def graphicsCache(self):
113        if not self._wasReset:
114            raise RuntimeError("Core must be reset first")
115        return tile.CacheSet(self)
116
117    @cached_property
118    def tiles(self):
119        t = []
120        ts = ffi.addressof(self.graphicsCache.cache.tiles)
121        for i in range(lib.mTileCacheSetSize(ts)):
122            t.append(tile.TileView(lib.mTileCacheSetGetPointer(ts, i)))
123        return t
124
125    @cached_property
126    def maps(self):
127        m = []
128        ms = ffi.addressof(self.graphicsCache.cache.maps)
129        for i in range(lib.mMapCacheSetSize(ms)):
130            m.append(tile.MapView(lib.mMapCacheSetGetPointer(ms, i)))
131        return m
132
133    @classmethod
134    def _init(cls, native):
135        core = ffi.gc(native, native.deinit)
136        success = bool(core.init(core))
137        lib.mCoreInitConfig(core, ffi.NULL)
138        if not success:
139            raise RuntimeError("Failed to initialize core")
140        return cls._detect(core)
141
142    @classmethod
143    def _detect(cls, core):
144        if hasattr(cls, 'PLATFORM_GBA') and core.platform(core) == cls.PLATFORM_GBA:
145            from .gba import GBA
146            return GBA(core)
147        if hasattr(cls, 'PLATFORM_GB') and core.platform(core) == cls.PLATFORM_GB:
148            from .gb import GB
149            return GB(core)
150        return Core(core)
151
152    def _load(self):
153        self._wasReset = True
154
155    def loadFile(self, path):
156        return bool(lib.mCoreLoadFile(self._core, path.encode('UTF-8')))
157
158    def isROM(self, vf):
159        return bool(self._core.isROM(vf.handle))
160
161    def loadROM(self, vf):
162        return bool(self._core.loadROM(self._core, vf.handle))
163
164    def loadBIOS(self, vf, id=0):
165        return bool(self._core.loadBIOS(self._core, vf.handle, id))
166
167    def loadSave(self, vf):
168        return bool(self._core.loadSave(self._core, vf.handle))
169
170    def loadTemporarySave(self, vf):
171        return bool(self._core.loadTemporarySave(self._core, vf.handle))
172
173    def loadPatch(self, vf):
174        return bool(self._core.loadPatch(self._core, vf.handle))
175
176    def loadConfig(self, config):
177        lib.mCoreLoadForeignConfig(self._core, config._native)
178
179    def autoloadSave(self):
180        return bool(lib.mCoreAutoloadSave(self._core))
181
182    def autoloadPatch(self):
183        return bool(lib.mCoreAutoloadPatch(self._core))
184
185    def autoloadCheats(self):
186        return bool(lib.mCoreAutoloadCheats(self._core))
187
188    def platform(self):
189        return self._core.platform(self._core)
190
191    def desiredVideoDimensions(self):
192        width = ffi.new("unsigned*")
193        height = ffi.new("unsigned*")
194        self._core.desiredVideoDimensions(self._core, width, height)
195        return width[0], height[0]
196
197    def setVideoBuffer(self, image):
198        self._core.setVideoBuffer(self._core, image.buffer, image.stride)
199
200    def reset(self):
201        self._core.reset(self._core)
202        self._load()
203
204    @needsReset
205    @protected
206    def runFrame(self):
207        self._core.runFrame(self._core)
208
209    @needsReset
210    @protected
211    def runLoop(self):
212        self._core.runLoop(self._core)
213
214    @needsReset
215    def step(self):
216        self._core.step(self._core)
217
218    @staticmethod
219    def _keysToInt(*args, **kwargs):
220        keys = 0
221        if 'raw' in kwargs:
222            keys = kwargs['raw']
223        for key in args:
224            keys |= 1 << key
225        return keys
226
227    def setKeys(self, *args, **kwargs):
228        self._core.setKeys(self._core, self._keysToInt(*args, **kwargs))
229
230    def addKeys(self, *args, **kwargs):
231        self._core.addKeys(self._core, self._keysToInt(*args, **kwargs))
232
233    def clearKeys(self, *args, **kwargs):
234        self._core.clearKeys(self._core, self._keysToInt(*args, **kwargs))
235
236    @property
237    @needsReset
238    def frameCounter(self):
239        return self._core.frameCounter(self._core)
240
241    @property
242    def frameCycles(self):
243        return self._core.frameCycles(self._core)
244
245    @property
246    def frequency(self):
247        return self._core.frequency(self._core)
248
249    @property
250    def gameTitle(self):
251        title = ffi.new("char[16]")
252        self._core.getGameTitle(self._core, title)
253        return ffi.string(title, 16).decode("ascii")
254
255    @property
256    def gameCode(self):
257        code = ffi.new("char[12]")
258        self._core.getGameCode(self._core, code)
259        return ffi.string(code, 12).decode("ascii")
260
261    def addFrameCallback(self, cb):
262        self._callbacks.videoFrameEnded.append(cb)
263
264    @property
265    def crc32(self):
266        return self._native.romCrc32
267
268class ICoreOwner(object):
269    def claim(self):
270        raise NotImplementedError
271
272    def release(self):
273        raise NotImplementedError
274
275    def __enter__(self):
276        self.core = self.claim()
277        self.core._protected = True
278        return self.core
279
280    def __exit__(self, type, value, traceback):
281        self.core._protected = False
282        self.release()
283
284class IRunner(object):
285    def pause(self):
286        raise NotImplementedError
287
288    def unpause(self):
289        raise NotImplementedError
290
291    def useCore(self):
292        raise NotImplementedError
293
294    def isRunning(self):
295        raise NotImplementedError
296
297    def isPaused(self):
298        raise NotImplementedError
299
300class Config(object):
301    def __init__(self, native=None, port=None, defaults={}):
302        if not native:
303            self._port = ffi.NULL
304            if port:
305                self._port = ffi.new("char[]", port.encode("UTF-8"))
306            native = ffi.gc(ffi.new("struct mCoreConfig*"), lib.mCoreConfigDeinit)
307            lib.mCoreConfigInit(native, self._port)
308        self._native = native
309        for key, value in defaults.items():
310            if isinstance(value, bool):
311                value = int(value)
312            lib.mCoreConfigSetDefaultValue(self._native, ffi.new("char[]", key.encode("UTF-8")), ffi.new("char[]", str(value).encode("UTF-8")))
313
314    def __getitem__(self, key):
315        string = lib.mCoreConfigGetValue(self._native, ffi.new("char[]", key.encode("UTF-8")))
316        if not string:
317            return None
318        return ffi.string(string)
319
320    def __setitem__(self, key, value):
321        if isinstance(value, bool):
322            value = int(value)
323        lib.mCoreConfigSetValue(self._native, ffi.new("char[]", key.encode("UTF-8")), ffi.new("char[]", str(value).encode("UTF-8")))