Changeset 229:329b3044ddef


Ignore:
Timestamp:
Sep 4, 2013, 4:40:00 PM (7 years ago)
Author:
Jeremy Thurgood <firxen@…>
Branch:
default
Message:

Much better facing renderers.

Files:
14 added
4 edited

Legend:

Unmodified
Added
Removed
  • nagslang/enemies.py

    r218 r229  
     1import math
     2
    13import pymunk
    24import pymunk.pygame_util
     
    6668
    6769    def get_render_angle(self):
    68         return self.angle
     70        # No image rotation when rendering, please.
     71        return 0
     72
     73    def get_facing_direction(self):
     74        # Enemies can face left or right.
     75        if - math.pi / 2 < self.angle <= math.pi / 2:
     76            return 'right'
     77        else:
     78            return 'left'
    6979
    7080    def _switch_direction(self):
  • nagslang/game_object.py

    r224 r229  
    118118        return self.physicser.get_angle()
    119119
     120    def get_facing_direction(self):
     121        """Used by rendererd that care what direction an object is facing.
     122        """
     123        return None
     124
    120125    def render(self, surface):
    121126        return self.renderer.render(surface)
  • nagslang/protagonist.py

    r218 r229  
    11import pymunk
    22import pymunk.pygame_util
     3from pymunk.vec2d import Vec2d
    34
    45import math
     
    2930class ProtagonistFormSelectionRenderer(render.RendererSelectionRenderer):
    3031    def select_renderer(self):
    31         return self.game_object.render_form
     32        return self.game_object.form
    3233
    3334
     
    3940
    4041    HUMAN_FORM = 'human'
    41     HUMAN_FORM_BACK = 'human_back'
    4242    WOLF_FORM = 'wolf'
    43     WOLF_FORM_BACK = 'wolf_back'
    4443
    4544    def __init__(self, space, position):
     
    4847        self.inventory = {}
    4948        self.form = self.HUMAN_FORM
    50         self.render_form = self.HUMAN_FORM
    5149        self.angle = 0
    5250        self.is_moving = False
     
    8987            self.HUMAN_FORM: render.FacingSelectionRenderer(
    9088                {
    91                     'left': render.MovementAnimatedRenderer(
    92                         [self._get_image('human_1.png'),
    93                          self._get_image('human_2.png')], 3),
    94                     'right': render.MovementAnimatedRenderer(
    95                         [self._get_image('human_1.png', FLIP_H),
    96                          self._get_image('human_2.png', FLIP_H)], 3),
    97                 }),
    98             self.HUMAN_FORM_BACK: render.FacingSelectionRenderer(
    99                 {
    100                     'left': render.MovementAnimatedRenderer(
    101                         [self._get_image('human_back_1.png'),
    102                          self._get_image('human_back_2.png')], 3),
    103                     'right': render.MovementAnimatedRenderer(
    104                         [self._get_image('human_back_1.png', FLIP_H),
    105                          self._get_image('human_back_2.png', FLIP_H)], 3),
     89                    'N': render.MovementAnimatedRenderer(
     90                        [self._get_image('human_N_1.png'),
     91                         self._get_image('human_N_2.png')], 3),
     92                    'S': render.MovementAnimatedRenderer(
     93                        [self._get_image('human_S_1.png'),
     94                         self._get_image('human_S_2.png')], 3),
     95                    'W': render.MovementAnimatedRenderer(
     96                        [self._get_image('human_W_1.png'),
     97                         self._get_image('human_W_2.png')], 3),
     98                    'E': render.MovementAnimatedRenderer(
     99                        [self._get_image('human_W_1.png', FLIP_H),
     100                         self._get_image('human_W_2.png', FLIP_H)], 3),
     101                    'NW': render.MovementAnimatedRenderer(
     102                        [self._get_image('human_NW_1.png'),
     103                         self._get_image('human_NW_2.png')], 3),
     104                    'NE': render.MovementAnimatedRenderer(
     105                        [self._get_image('human_NW_1.png', FLIP_H),
     106                         self._get_image('human_NW_2.png', FLIP_H)], 3),
     107                    'SW': render.MovementAnimatedRenderer(
     108                        [self._get_image('human_SW_1.png'),
     109                         self._get_image('human_SW_2.png')], 3),
     110                    'SE': render.MovementAnimatedRenderer(
     111                        [self._get_image('human_SW_1.png', FLIP_H),
     112                         self._get_image('human_SW_2.png', FLIP_H)], 3),
    106113                }),
    107114            self.WOLF_FORM: render.FacingSelectionRenderer(
    108115                {
    109                     'left': render.MovementAnimatedRenderer(
    110                         [self._get_image('werewolf_1.png'),
    111                          self._get_image('werewolf_2.png')], 3),
    112                     'right': render.MovementAnimatedRenderer(
    113                         [self._get_image('werewolf_1.png', FLIP_H),
    114                          self._get_image('werewolf_2.png', FLIP_H)], 3),
    115                 }),
    116             self.WOLF_FORM_BACK: render.FacingSelectionRenderer(
    117                 {
    118                     'left': render.MovementAnimatedRenderer(
    119                         [self._get_image('werewolf_back_1.png'),
    120                          self._get_image('werewolf_back_2.png')], 3),
    121                     'right': render.MovementAnimatedRenderer(
    122                         [self._get_image('werewolf_back_1.png', FLIP_H),
    123                          self._get_image('werewolf_back_2.png', FLIP_H)], 3),
     116                    'N': render.MovementAnimatedRenderer(
     117                        [self._get_image('werewolf_N_1.png'),
     118                         self._get_image('werewolf_N_2.png')], 3),
     119                    'S': render.MovementAnimatedRenderer(
     120                        [self._get_image('werewolf_S_1.png'),
     121                         self._get_image('werewolf_S_2.png')], 3),
     122                    'W': render.MovementAnimatedRenderer(
     123                        [self._get_image('werewolf_W_1.png'),
     124                         self._get_image('werewolf_W_2.png')], 3),
     125                    'E': render.MovementAnimatedRenderer(
     126                        [self._get_image('werewolf_W_1.png', FLIP_H),
     127                         self._get_image('werewolf_W_2.png', FLIP_H)], 3),
     128                    'NW': render.MovementAnimatedRenderer(
     129                        [self._get_image('werewolf_NW_1.png'),
     130                         self._get_image('werewolf_NW_2.png')], 3),
     131                    'NE': render.MovementAnimatedRenderer(
     132                        [self._get_image('werewolf_NW_1.png', FLIP_H),
     133                         self._get_image('werewolf_NW_2.png', FLIP_H)], 3),
     134                    'SW': render.MovementAnimatedRenderer(
     135                        [self._get_image('werewolf_SW_1.png'),
     136                         self._get_image('werewolf_SW_2.png')], 3),
     137                    'SE': render.MovementAnimatedRenderer(
     138                        [self._get_image('werewolf_SW_1.png', FLIP_H),
     139                         self._get_image('werewolf_SW_2.png', FLIP_H)], 3),
    124140                }),
    125141        })
     
    134150
    135151    def get_render_angle(self):
    136         return self.angle
     152        # No image rotation when rendering, please.
     153        return 0
     154
     155    def get_facing_direction(self):
     156        # It's easier to work with a vector than an angle here.
     157        vec = Vec2d.unit()
     158        vec.angle = self.angle
     159        # We probably don't have exactly -1, 0, or 1 here.
     160        x = int(round(vec.x))
     161        y = int(round(vec.y))
     162
     163        return {
     164            (0, 1): 'N',
     165            (0, -1): 'S',
     166            (-1, 0): 'W',
     167            (1, 0): 'E',
     168            (1, 1): 'NE',
     169            (1, -1): 'SE',
     170            (-1, 1): 'NW',
     171            (-1, -1): 'SW',
     172        }[(x, y)]
    137173
    138174    def go_werewolf(self):
     
    141177        self.impulse_factor = 4000
    142178
    143         if self.render_form == self.HUMAN_FORM:
    144             self.render_form = self.WOLF_FORM
    145         elif self.render_form == self.HUMAN_FORM_BACK:
    146             self.render_form = self.WOLF_FORM_BACK
    147         else:
    148             self.render_form = self.WOLF_FORM
    149 
    150179    def go_human(self):
    151180        self.physicser.switch_form(self.form, self.HUMAN_FORM)
    152181        self.form = self.HUMAN_FORM
    153182        self.impulse_factor = 500
    154 
    155         if self.render_form == self.WOLF_FORM:
    156             self.render_form = self.HUMAN_FORM
    157         elif self.render_form == self.WOLF_FORM_BACK:
    158             self.render_form = self.HUMAN_FORM_BACK
    159         else:
    160             self.render_form = self.HUMAN_FORM
    161 
    162     def _switch_to_back(self):
    163         if self.render_form == self.HUMAN_FORM:
    164             self.render_form = self.HUMAN_FORM_BACK
    165         elif self.render_form == self.WOLF_FORM:
    166             self.render_form = self.WOLF_FORM_BACK
    167 
    168     def _switch_to_front(self):
    169         if self.render_form == self.HUMAN_FORM_BACK:
    170             self.render_form = self.HUMAN_FORM
    171         elif self.render_form == self.WOLF_FORM_BACK:
    172             self.render_form = self.WOLF_FORM
    173183
    174184    def set_direction(self, dx, dy):
     
    177187            return
    178188        self.is_moving = True
    179         old_angle = self.angle
    180189        self.angle = pymunk.Vec2d((dx, dy)).angle
    181         # If we've gone from quadrants 2 & 3 to 1 & 4 (or vice versa)
    182         # switch between front & back views
    183         if self.angle != math.pi:
    184             # == math.pi is going straight left, which can't
    185             # trigger a front/back swap and simplifies these checks
    186             if self.angle > 0 and old_angle != self.angle:
    187                 self._switch_to_back()
    188             elif self.angle < 0 and old_angle != self.angle:
    189                 self._switch_to_front()
    190190        self.physicser.apply_impulse(
    191191            (dx * self.impulse_factor, dy * self.impulse_factor))
     
    200200        self.form = old_protagonist.form
    201201        self.angle = old_protagonist.angle
    202         self.render_form = old_protagonist.render_form
    203202        self.inventory = old_protagonist.inventory
    204203
  • nagslang/render.py

    r222 r229  
    135135
    136136class FacingSelectionRenderer(RendererSelectionRenderer):
    137     def __init__(self, renderers):
    138         for renderer in renderers.values():
    139             renderer.rotate = False
    140         super(FacingSelectionRenderer, self).__init__(renderers)
    141         self._face = 'left'
    142 
    143     def _update_facing(self, angle):
    144         if abs(angle) < math.pi / 2:
    145             self._face = 'right'
    146         elif abs(angle) > math.pi / 2:
    147             self._face = 'left'
    148 
    149137    def select_renderer(self):
    150         angle = self.game_object.get_render_angle()
    151         self._update_facing(angle)
    152         return self._face
     138        return self.game_object.get_facing_direction()
    153139
    154140
Note: See TracChangeset for help on using the changeset viewer.