(defclass $circle ()
    (($center :accessor center :initarg :center :type $point)
    ($radius :accessor radius :initarg :radius)
    )
)

(defclass $square ()
    (($corner :accessor corner :initarg :corner :type $point)
    ($w :accessor w :initarg :w)
    )
)

(defclass $rectangle ()
    (($corner :accessor corner :initarg :corner :type $point)
    ($w :accessor w :initarg :w)
    ($h :accessor h :initarg :h)
    )
)

(defclass $triangle ()
    (($M1 :accessor M1 :initarg :M1 :type $point)
    ($M2 :accessor M2 :initarg :M2 :type $point)
    ($M3 :accessor M3 :initarg :M3 :type $point)
    )
)

(defclass $polygon ()
    (($summitList :accessor summitList :initarg :summitList)
    )
)

(defclass $point ()
    (($x :accessor x :initarg :x :type float)
    ($y :accessor y :initarg :y :type float)
    )
)





; Methods for points

defmethod =translate ((pt $point) dx dy)
    (setf (x pt) (+ (x pt) dx))
    (setf (y pt) (+ (y pt) dy))
)

(defmethod =symx ((pt $point))
    (setf (x pt) (- 0 (x pt)))
)

(defmethod =symy ((pt $point))
    (setf (y pt) (- 0 (y pt)))
)

(defmethod =symo ((pt $point))
    (=symx (x pt))
    (=symy (y pt))
)

defmethod =duplicate ((pt $point) dx dy)
    (make-point (+ (x pt) dx) (+ (y pt) dy))
)

; Methods for triangle

(defmethod =translateTri ((tr $triangle) dx dy)
    (=translate (M1 tr) dx dy)
    (=translate (M2 tr) dx dy)
    (=translate (M3 tr) dx dy)
)

(defmethod =symxTri ((tr $triangle))
    (=symx (M1 tr))
    (=symx (M2 tr))
    (=symx (M3 tr))
)

(defmethod =symyTri ((tr $triangle))
    (=symy (M1 tr))
    (=symy (M2 tr))
    (=symy (M3 tr))
)

(defmethod =symoTri ((tr $triangle))
    (=symo (M1 tr))
    (=symo (M2 tr))
    (=symo (M3 tr))
)

(defmethod =duplicateTri ((tr $triangle) dx dy)
    (make-triangle (+ (x (M1 tr)) dx) (+ (y (M1 tr)) dy) (+ (x (M2 tr)) dx)
(+ (y (M2 tr)) dy) (+ (x (M3 tr)) dx) (+ (y (M3 tr)) dy))
)

; Methods for square

(defmethod =translateSq ((sq $square) dx dy)
    (=translate (M sq) dx dy)
)

(defmethod =symxSq ((sq $square))
    (=symx (M sq))
    (=translate (M sq) (- 0 (w ca)) 0)
)

(defmethod =symySq ((sq $square))
    (=symy (M sq))
    (=translate (M sq) 0 (- 0 (w sq)))
)

(defmethod =symoSq ((sq $square))
    (=symo (M sq))
    (=translate (M sq) (- 0 (w sq)) (- 0 (w sq)))
)

(defmethod =duplicateSq ((sq $square) dx dy)
    (make-carre (+ (X (M sq)) dx) (+ (Y (M sq)) dy) (w sq))
)

; Methods for rectangle

(defmethod =translateRec ((rec $rectangle) dx dy)
    (=translate (M rec) dx dy)
)

(defmethod =symxRec ((rec $rectangle))
    (=symx (M rec))
    (=translate (M rec) (- 0 (w rec)) 0)
)

(defmethod =symyRec ((rec $rectangle))
    (=symy (M rec))
    (=translate (M ca) 0 (- 0 (w rec)))
)

(defmethod =symoRec ((rec $rectangle))
    (=symo (M rec))
    (=translate (M ca) (- 0 (w rec)) (- 0 (h rec)))
)

(defmethod =duplicateRec ((rec $rectangle) dx dy)
    (make-rectangle (+ (X (M rec)) dx) (+ (Y (M rec)) dy) (w rec) (h rec))
)
; Methods for circle

(defmethod =translateCir ((ci $circle) dx dy)
    (=translate (C ci) dx dy)
)

(defmethod =symxCir ((ci $circle))
    (=symx (C ci))
)

(defmethod =symyCi ((ci $cercle))
    (=symy (C ci))
)

(defmethod =symo ((ci $circle))
    (=symo (C ci))
)

(defmethod =duplicateCi ((ci $circle) dx dy)
    (make-cercle (+ (X (C ci)) dx) (+ (Y (C ci)) dy) (r ci))
)
; Methods for polygon

(defmethod =translatePol ((poly $polygon) dx dy)
    (dolist (s (summitList poly))
        (=translate s dx dy)
    )
)

(defmethod =symxPol ((poly $polygon))
    (dolist (s (summitList poly))
        (=symx s)
    )
)

(defmethod =symyPol ((poly $polygone))
    (dolist (s (summitList poly))
        (=symy s)
    )
)

(defmethod =symoPol ((poly $polygone))
    (dolist (s (summitList poly))
        (=symo s)
    )
)

(defmethod =duplicatePol ((poly $polygone) dx dy)
    (let (pts)
        (dolist (pt (summitList poly))
            (push (make-point (+ (car pt) dx) (+ (cadr pt) dy)) pts)
        )
        (make-polygone (reverse ptsUpdate))
    )
)