Relay movement state

client/src/arena.lisp

@@ -39,7 +39,8 @@
              (update-proxy dude
                            (sequence->vec2 (getf dude-state :position))
                            (sequence->vec2(getf dude-state :rotation))
                            timestamp))))))))
                            timestamp
                            (getf dude-state :movement)))))))))


(defun shoot-ball (player)

client/src/dude.lisp

@@ -1,6 +1,8 @@
(in-package :mortar-combat)


(define-constant +animation-overlap+ 0.15)

(defvar *dude-bounds-initial-position* (vec4 0.0 7.5 0.0 1.0))
(defvar *dude-bounds-initial-rotation* (euler-angles->mat4 (vec4 (/ pi 2) 0.0 0.0)))

@@ -77,6 +79,7 @@
;;;
(defclass dude-model (model)
  ((mesh :initform nil)
   (movement-listener :initform nil)
   (body :initform nil)
   (player :initarg :player)
   (program :initform nil)
@@ -91,8 +94,9 @@


(defmethod initialization-flow ((this dude-model) &key)
  (with-slots (mesh animation skeleton program body
                    strafe-animation run-animation rest-animation)
  (with-slots (mesh animation skeleton program body (dude player)
                    strafe-animation run-animation rest-animation
                    movement-listener)
      this
    (>> (resource-flow "mesh.Dude" "Stickman"
                       "animation.Resting"
@@ -108,11 +112,28 @@
                program p))
        (-> ((physics)) ()
          (setf body (make-instance 'dude-body)))
        (call-next-method))))
        (call-next-method)
        (instantly ()
          (let ((ani-player (find-node (model-root-of this) :dude-animation)))
            (setf movement-listener
                  (subscribe-body-to (movement-changed (player direction)) (events)
                    (run (-> ((mortar-combat)) ()
                            (when (eq dude player)
                              (case direction
                                (:north (play-node-animation ani-player
                                                             run-animation
                                                             +animation-overlap+))
                                (:east (play-node-animation ani-player
                                                            strafe-animation
                                                            +animation-overlap+))
                                (t (play-node-animation ani-player
                                                        rest-animation
                                                        +animation-overlap+)))))))))))))


(defmethod discard-node ((this dude-model))
  (with-slots (body) this
  (with-slots (body movement-listener) this
    (unsubscribe-from 'movement-changed movement-listener (events))
    (dispose body)))

client/src/events.lisp

@@ -38,7 +38,7 @@


(defevent movement-changed ()
  (direction))
  (player direction))


(defevent trigger-pulled () ())

client/src/game-client.lisp

@@ -24,6 +24,7 @@
                     :no-reply t
                     :name (name-of player)
                     :timestamp (real-time-seconds)
                     :movement (movement-of player)
                     :position (list (x pos) (y pos))
                     :rotation (list (x rot) (y rot)))
             ()))))

client/src/game-server.lisp

@@ -22,9 +22,13 @@

(defmethod process-command ((command (eql :player-info)) message)
  (with-slots (arena) *connector*
    (with-message (name position rotation timestamp) message
    (with-message (name position rotation timestamp movement) message
      (when-let ((player (find-dude arena name)))
        (update-proxy player (sequence->vec2 position) (sequence->vec2 rotation) timestamp))))
        (update-proxy player
                      (sequence->vec2 position)
                      (sequence->vec2 rotation)
                      timestamp
                      movement))))
  nil)


@@ -35,7 +39,8 @@
                   (rot (rotation-of p)))
             (list :name (name-of p)
                   :position (list (x pos) (y pos))
                   :rotation (list (x rot) (y rot))))))
                   :rotation (list (x rot) (y rot))
                   :movement (movement-of p)))))
      (let ((proxies (mapcar #'player-info (cons (player-of arena) (dudes-of arena)))))
        (run (-> (server :command :game-state
                         :no-reply t

client/src/main.lisp

@@ -104,7 +104,7 @@


(defmethod initialize-system :after ((this mortar-combat))
  (with-slots (scene keymap task-queue game-client identity) this
  (with-slots (scene keymap task-queue game-client identity arena) this
    (register-resource-loader (make-resource-loader (asset-path "font.brf")
                                                    (asset-path "dude-and-mortar.brf")))
    (register-event-classes (events)
@@ -144,7 +144,8 @@
                                                 ('(:w :d) :north-east)
                                                 ('(:s :a) :south-west)
                                                 ('(:s :d) :south-east))))))
                     (post (make-movement-changed direction) eve))))
                     (when arena
                       (post (make-movement-changed (player-of arena) direction) eve)))))
               (update-buttons (button)
                 (lambda (state)
                   (case state

client/src/player.lisp

@@ -69,7 +69,8 @@

(defmethod initialize-instance :after ((this player) &key)
  (flet ((update-movement (ev)
           (setf (movement-of this) (direction-from ev)))
           (when (eq (player-from ev) this)
             (setf (movement-of this) (direction-from ev))))
         (update-rotation (ev)
           (look-at this (ax-from ev) (ay-from ev))))
    (register-event-handler 'camera-rotated #'update-rotation)

client/src/proxy.lisp

@@ -3,7 +3,7 @@

(defclass proxy ()
  ((name :initarg :name :initform (error ":name missing") :reader name-of)
   (movement :initform nil)
   (movement :initform nil :reader movement-of)
   (position :initform (vec2)) ; f(x,y) field space = f(x,-z) global space
   (rotation :initform (vec2) :reader rotation-of)
   (updated-at :initform (real-time-seconds))
@@ -32,10 +32,15 @@
    (lerp rotation next-rotation (proxy-lerp-factor this))))


(defun update-proxy (proxy pos rot timestamp)
  (with-slots (next-position next-at position updated-at
                             correction rotation next-rotation)
(defun update-proxy (proxy pos rot timestamp movement)
  (with-slots (next-position
               next-at position updated-at
               correction rotation next-rotation
               (this-movement movement))
      proxy
    (unless (eq this-movement movement)
      (setf this-movement movement)
      (post (make-movement-changed proxy movement) (events)))
    (setf correction (- (real-time-seconds) timestamp)

          position (position-of proxy)