def set_image(self, image):
if image is None:
self._cObj.SetImage(None)
return
if isinstance(image, Bitmap):
image = ResourceManager._create_image(image)
elif isinstance(image, pygame.Surface):
image = ResourceManager._create_image(Bitmap(image))
elif not isinstance(image, ImageInstance):
image = ResourceManager.get_image(image)
self._image = image
self._cObj.SetImage(image._cObj)
def __init__(self, frames, fps=None, secs=1, mode=StopMode, start_frame=0, start_direction=1):
_CAction.__init__(self)
if isinstance(frames, basestring):
frames = ResourceManager.get_pattern(frames)
self.frames = frames
if fps is not None:
self.delay = 1.0/fps
else:
self.delay = float(secs)/len(self.frames)
self.mode = mode
self.frame = start_frame
self.direction = start_direction
def __init__(self,
frames,
fps=None,
secs=1,
mode=StopMode,
start_frame=0,
start_direction=1):
_CAction.__init__(self)
if isinstance(frames, basestring):
frames = ResourceManager.get_pattern(frames)
self.frames = frames
if fps is not None:
self.delay = 1.0 / fps
else:
self.delay = float(secs) / len(self.frames)
self.mode = mode
self.frame = start_frame
self.direction = start_direction
def emit(cls, system, position=None):
node = None
if isinstance(position, Node):
node = position
cls.prepare()
cobj = cls._cImpl()
cobj.InitFrom(cls._cTemplate)
if node is not None:
cobj.AttachTo(node._cObj)
else:
cobj.SetPosition(_c.Vec2(*position))
cobj.SetSystem(system._cObj)
pyobj = ParticleEmitterInstance(cobj)
pyobj._argcache = cls._argcache
if cls.image is not None:
image = ResourceManager.get_image(cls.image)
if image is None:
raise ValueError("could not load image %r" % imagename)
pyobj.image = image
cobj.image = image._cObj
cobj.Start()
return pyobj
def emit(cls, system, position=None):
node = None
if isinstance(position, Node):
node = position
cls.prepare()
cobj = cls._cImpl()
cobj.InitFrom(cls._cTemplate)
if node is not None:
cobj.AttachTo(node._cObj)
else:
cobj.SetPosition(_c.Vec2(*position))
cobj.SetSystem(system._cObj)
pyobj = ParticleEmitterInstance(cobj)
pyobj._argcache = cls._argcache
if cls.image is not None:
image = ResourceManager.get_image(cls.image)
if image is None:
raise ValueError("could not load image %r" % imagename)
pyobj.image = image
cobj.image = image._cObj
cobj.Start()
return pyobj
def run(self, initialScene, *args, **kw):
"""Run the Director mainloop until program exit
"""
try:
# This is a long and ugly function that hasn't been splitted into smaller parts
# because of performance considerations.
#
import pygame
pygame.init()
from Opioid2D.public.Mouse import Mouse
# Bind functions to local names in order to increase performance
sleep = time.sleep
throttle = pygame.time.Clock()
flip = pygame.display.flip
get_ticks = pygame.time.get_ticks
cD = self._cDirector
OM = ObjectManager
self._scene = None
self.next_scene = None
self.next_state = None
now = get_ticks()
cD.Start(now)
self.set_scene(initialScene, *args, **kw)
self._running = True
start = time.time()
frames = 0
self.delta = 0
ticker = cD.GetTicker()
old_ticks = now
self.now = now
# Preload Image subclasses that have been imported and that
# contain the preload flag.
for img in ImageMeta.subclasses:
if img.preload:
ResourceManager.get_image(img)
while self._running:
# Trigger possible scene change at the beginning of a new frame
if self.next_scene is not None:
self._change_scene()
# Time delta calculation
ticks = get_ticks()
self.delta = delta = min(ticks-old_ticks, 25) # limit the virtual clock to a max. advance of 25ms per frame
old_ticks = ticks
self.now = now = now + delta
cD.Iterate(now)
scene = self._scene
cscene = scene._cObj
cscene.Tick()
# Event handling
ev = pygame.event.get()
if scene._gui is not None:
scene._gui.tick(ev)
scene._handle_events(ev)
# Call Scene tick callbacks
if scene._tickfunc is not None:
scene._tickfunc()
if ticker.realTick:
if scene._realtickfunc is not None:
scene._realtickfunc()
# Manage state change within the scene
while self.next_state is not None:
s = self.next_state
self.next_state = None
self.scene._init_state(s)
# Update the screen
cD.RenderFrame()
# render software mouse cursor
ms = Mouse._sprite
if ms:
ms.position = Mouse.position
ms._cObj.TraverseFree()
flip()
# Purge managed C++ objects that have been killed on the C++ side.
OM.purge()
frames += 1
throttle.tick(100) # limit FPS to 100 for lower CPU usage
end = time.time()
finally:
from Opioid2D import _opi2d
_opi2d.cleanup()
return frames/(end-start)
def newrun(initialScene, *args, **kw):
"""Run the Director mainloop until program exit
"""
self = PigDirector
try:
# This is a long and ugly function that hasn't been splitted into smaller parts
# because of performance considerations.
import pygame
pygame.init()
from Opioid2D.public.Mouse import Mouse
# Bind functions to local names in order to increase performance
sleep = time.sleep
throttle = pygame.time.Clock()
flip = pygame.display.flip
get_ticks = pygame.time.get_ticks
cD = self._cDirector
OM = ObjectManager
self._scene = None
self.next_scene = None
self.next_state = None
self.paused = False
self.project_started = False
now = get_ticks()
cD.Start(now)
self.set_scene(initialScene, *args, **kw)
self._running = True
start = time.time()
frames = 0
self.delta = 0
ticker = cD.GetTicker()
old_ticks = now
self.now = now
self.switch_scene = None
# Preload Image subclasses that have been imported and that
# contain the preload flag.
for img in ImageMeta.subclasses:
if img.preload:
ResourceManager.get_image(img)
while self._running:
# Trigger possible scene change at the beginning of a new frame
if self.next_scene is not None:
scene = None
self._change_scene()
if self.switch_scene is not None:
scene = None
if isclass( self.switch_scene):
self._scene = self.switch_scene()
else:
self._scene = self.switch_scene
cD.SetScene( self._scene._cObj)
if isclass( self.switch_scene):
self._scene.enter()
self.switch_scene = None
import wx
wx.CallAfter(wx.GetApp().refresh)
# Time delta calculation
ticks = get_ticks()
self.delta = delta = min(ticks-old_ticks, 25) # limit the virtual clock to a max. advance of 25ms per frame
old_ticks = ticks
self.now = now = now + delta
cD.Iterate(now)
scene = self._scene
cscene = scene._cObj
if not self.paused:
cscene.Tick()
# Call Scene tick callbacks
if scene._tickfunc is not None:
scene._tickfunc()
if ticker.realTick:
if scene._realtickfunc is not None:
scene._realtickfunc()
# Event handling
ev = pygame.event.get()
if scene.mouse_manager is not None:
scene.mouse_manager.tick(ev)
scene._handle_events(ev)
# Manage state change within the scene
while self.next_state is not None:
s = self.next_state
self.next_state = None
self.scene._init_state(s)
# Update the screen
cD.RenderFrame()
# render software mouse cursor
ms = Mouse._sprite
if ms:
ms.position = Mouse.position
ms._cObj.TraverseFree()
flip()
# Purge managed C++ objects that have been killed on the C++ side.
OM.purge()
frames += 1
throttle.tick(100) # limit FPS to 100 for lower CPU usage
end = time.time()
finally:
from Opioid2D import _opi2d
_opi2d.cleanup()
return frames/(end-start)
def transform(self, mode):
from Opioid2D.public.ResourceManager import ResourceManager
k = self._key
if mode not in k.mode:
return ResourceManager.get_image(k, mode=k.mode + [mode])
return self
def transform(self, mode):
from Opioid2D.public.ResourceManager import ResourceManager
k = self._key
if mode not in k.mode:
return ResourceManager.get_image(k, mode=k.mode+[mode])
return self
class Sprite(Node):
"""The Sprite is a Node that has a graphical presentation
The usual way to use Sprites is to subclass the Sprite class
and set the following class attributes:
group - name of the SpriteGroup that instances of your sprite are automatically added to (can also be a list of names)
image - name of the imagefile that is loaded for all instances
layer - name of the layer that the instance is automatically placed on creation
lighting - boolean setting for automatically enabling or disabling lighting for instances
"""
__metaclass__ = SpriteMeta
_init_image = None
_init_layer = None
group = None
lighting = False
def __new__(cls, *arg, **kw):
obj = SpritePool.get_object()
obj.__class__ = cls
return obj
def __init__(self, img=None):
"""Create a Sprite that uses the given image
The image given can be an Image object or a string containing
the image filename.
"""
self._preinit(img)
self.on_create()
def _preinit(self, img):
if img is None:
img = self._init_image
if not hasattr(self, "_cObj") or self._cObj is None:
self._cObj = _c.Sprite()
self.set_image(img)
self._init()
self._get_physics()
group = self.group
if group is not None:
if type(group) not in (list, tuple):
group = (group,)
for g in group:
self.join_group(g)
if self._init_layer is not None:
self.set_layer(self._init_layer)
self.enable_lighting(self.lighting)
def delete(self):
if self.deleted:
return
self.on_delete()
Node.delete(self)
def on_create(self):
"""Callback that is invoked when the Sprite object is created.
Override in subclasses"""
pass
def on_delete(self):
"""Callback that is invoked when the Sprite object is deleted.
Override in subclasses"""
pass
def join_group(self, name):
"""Join a new sprite group"""
scene = Director.scene
group = scene.get_group(name)
self._cObj.JoinGroup(group._cObj)
def leave_group(self, name):
"""Leave a sprite group"""
scene = Director.scene
grp = scene.get_group(name)
self._cObj.LeaveGroup(grp._cObj)
def enable_lighting(self, flag):
"""Enable or disable lighting for this sprite"""
self._cObj.EnableLighting(flag)
def set_color(self, rgba):
if len(rgba) == 3:
rgba = rgba + (1,)
self._cObj.GetColor().set(*rgba)
def get_color(self):
c = self._cObj.GetColor()
return (c.red, c.green, c.blue, c.alpha)
color = property(get_color, set_color, doc="Color of the sprite in (r,g,b,a)")
def set_alpha(self, alpha):
self._cObj.GetColor().alpha = alpha
def get_alpha(self):
return self._cObj.GetColor().alpha
alpha = property(get_alpha, set_alpha, doc="Alpha value of the sprite")
def set_image(self, image):
if image is None:
self._cObj.SetImage(None)
return
if isinstance(image, Bitmap):
image = ResourceManager._create_image(image)
elif isinstance(image, pygame.Surface):
image = ResourceManager._create_image(Bitmap(image))
elif not isinstance(image, ImageInstance):
image = ResourceManager.get_image(image)
self._image = image
self._cObj.SetImage(image._cObj)
def get_image(self):
return self._image
#current_image = property(get_image, set_image)
def get_hotspot(self):
if self._image is None:
return 0,0
h = self._image.hotspot
return h.x,h.y
def set_hotspot(self, (x,y)):
if self._image is None:
return
img = ResourceManager.get_image(self._image, hotspot=(x,y))
self.image = img
def create_single(self, s):
surf = self.create_surface(s)
img = ResourceManager._create_image(Bitmap(surf))
return Sprite(img)
def create_single(self, s):
surf = self.create_surface(s)
img = ResourceManager._create_image(Bitmap(surf))
return Sprite(img)
