방랑시인의 공방

아이폰이 풀리면서 생기는 가장 강력한 변화는 무엇이될까?

그것은 지금까지 컨텐츠에 접근 권한을 오롯이 독점했던 통신사들이, 그 권한을 사용자에게 넘겨주어야한다는 것이다. 이제 사용자들은 자신이 원하는 곳에서 원하는 컨텐츠를 자유로이 구매할 수 있으며, 또 사용할 수 있게된다.

아이폰은 일종의 스마트폰이다. 손안에 들어가는 소형 정보단말기기라는 얘기. 말하자면 현재 우리가 PC 에서 가능한 거의 모든 작업은 어느 정도 처리가 가능하다는 것이다. 비니지스면에서는 더욱 구미가 당기는 분야가 있다. 작업이나 일같은 얘기가 아니다. 바로 쇼핑이다.

그렇다면 여기서 생기는 의문점이 있다. 어디에서? 어디에서 사야하는가?
그리고 그 상품에 대한 신뢰성은 어디에서 가져올 것인가?

프로그램은 앱스토어, 동영상/음악은 아이튠즈가 있다고 치자. 그럼 그 다음에 그것을 넘어서서 무엇이 있는가?

SKT주변에는 수많은 업체들을 가지고 있다. SNS는 싸이월드, 메신저는 네이트온, 쇼핑 사이트는 11번가, 멀티미디어는 멜론, 그리고 자체 앱스토어까지..
문제는 아직 이들이 제대로 통합된 이득을 가지고 있지 못하다는 것인데 그것도 머지않아 조금씩 통합이 완료될 것이라고 본다.
이미 싸이월드는 네이트온과 긴밀하게 접속되어있고, 11번가는 옥션과 함께 싸이월드와 네이트온에서 움직인다. 멜론은 말할 것도 없고.. 그렇다면 싸이월드 중심의 포털식 통합도 가능할 것이라고 본다.
싸이월드에서 앱, 게임, 음악, 영화, 동영상, 도서등등에 대한 전반적인 쇼핑정보를 개인들이 올리고, 이들을 토대로 구매가 이루어지는 구성이 최대한 빨리 이루어진다면 어마어마한 파급력을 가지지 않을까?

원하는 물품을 살 때 가장 먼저 찾는 곳은?
내 경우는 카메라는 SLRclub, PC는 보드나라, 유아용품은 맘스클럽등등이다. 즉 왠만한 정보가 빨리 모이는 커뮤니티로 저절로 움직이게된다. 말하자면 구매의 기준을 잡아주는 곳이 SNS사이트가 된다는 얘기다.

이제 스마트폰으로 사진을 찍으면, 해당 사진의 대상을 토대로, 바로 인터넷에서 제품을 검색해줄 수 있게된다. 그리고 그 제품에 대한 각종 정보는 SNS사이트를 돌아다니면서 얻어오게된다. 결제는? 바로 스마트폰에서 결제해버리면 끝이다. 통화료에 합산되서 나오면 되니까..

제품 검색은 11번가, 정보를 가져오는 곳은 싸이월드나 네이트, 결제는 이미 전화에서 진행되고 있고.. 이렇게 스마트폰에서 모든 것을 할 수 있는 사업자가 SKT이외에는 없는 것 같다. KT나 LGT가 신기술로 어떻게든 치고 나가고 싶어하지만, 문제는 신기술로 치고 나간다음에 바뀐 생태계에서 단숨에 이득을 거둘 수 있는 곳은 SKT 이외에는 보이지 않는다는 점..

스마트폰 사업을 통해서 제일 잘 나갈 곳은 SKT가 될 수 있을듯...

얼마전 BING이라는 검색엔진을 통해서 MS는 다시 검색엔진에 발을 들이밀었다. 시장의 60% 이상을 차지하는 구글이 버티고 서 있는 시장에서 새로운 엔진으로 2인자 위치까지 올라가는데는 성공한 것 같다. 아마도 최근에 잇따르고 있는 악재 - 소송에서 패하고, 개발해놓은 OS는 참패해 새로운 버전을 강조해야하고, 인텔과의 밀월관계는 어긋나기 시작하는 등 - 속에서 작은 불꽃같은 호재일 듯 하다.

MS의 사업분야는 현기증이 날정도로 다양하다.
내가 알고 있는 것만 정리하자면..

• 개인 PC시장에서는 OS, 오피스를 위시한 생산성 툴과, 개발툴을 지속적으로 출시하고 있고,
•  웹인프라쪽에서는 웹, DB, 트랜잭션등등 방대한 서버 솔루션,
  
• 인터넷쪽에서는 실버라이트를 위시한 각종 UX기술들과
  
• Live.com을 통한 각종 웹솔루션,Bing 이라는 신형 검색엔진
• 윈도 모바일의 핸드헬드 시장
• X 360으로 대표되는 엔터테인먼트 시장
• 각종 주변기기 - 키보드, 마우스등

등 전자제품이 소요되는 각종 인프라에는 거의 얼굴을 비치고 있다.

그런데 과연, MS는 어디로 가려고 하는지를 알 수가 없다. 통합된 방향을 찾기도 어렵고, 회사가 추구하려는 미래 가치는 어디에 있는지 알기도 어렵다. Technet같은데서 보여지는 미래 모습은 단순히 새로운 솔루션을 내보이는 것 같다. 마치 수많은 사업부가 자기 멋대로 진화하는 것을 그냥 내버려두고 있다고 할까... 통합된 움직임을 종합해 가늠할 수조차 없다.

2004년 빌 게이츠는 MS의 미래를 스마트 홈이라는 개념에서 찾으려고 했었다. 집안에 놓인 데이터 서버를 중심으로, 각중 기기들에 설치된 윈도 모바일 OS들이 조화를 이뤄가며 편리한 가정 자동화를 가져올 것이라고 이야기 했었다. 그런 개념에 가장 빨리 다가가고 있는 모델이 X 360이라고 생각한다. 얼마전의 NATAL에서 보여줬던 개념은 가정에서의 IT 기기를 고려하고 있는듯 보였다.

하지만 이런 개념자체가 아직도 유효한지는 의문이다. 스티브 발머 회장체제로 옮기면서, 지속적으로 인터넷 비지니스에 투자하고 있는데, 효과는 여전히 미지수에 가깝다.  과거에 시장을 선도하던 입장에서, 이제는 시장의 변화를 따라가기에도 급급해보인다. 기술적 흐름은 클라우드 컴퓨팅으로 빠르게 전이되고 있지만, 아직까지 MS에서는 단순히 몇몇 솔루션을 내보이고 있을 뿐, 전체적인 그림에 영향을 미칠정도는 되지 못하고 있다.

너무나 거대해져서 방향을 전환하기가 벅찬 모습을 보자면, MS가 이대로 고착되지 않나하는 생각도 든다.

현재 시장은 클라우드 컴퓨팅으로 대표되는 씬 클라이언트 시대로 이행하고 있다고 본다. 사람들은 다양한 기기를 가지고 다니면서, 과거보다 훨씬 복잡 다양한 방법으로 정보에 접근한다. 스마트 폰 같은 기기에서 현재 일어나는 다양한 개념을 보고 있자면, 과거처럼 강력한 수준의 기기와 그것을 통제하는 소프트웨어보다는, 각종 솔루션에 쉽게 접근해서 그 결과를 바로 받아볼 수 있는 정도만 되면 거의 충분한 시기가 되어가고 있는 것 같다. 복잡한 작업은 서버에서 이미 남을정도로 충분히 수행하니까..

이미 게임업계에서는 서버쪽에서 모든 연산을 담당하고 클라이언트에서는 정해진 결과만을 내보이는 모델이 주류화되었다. 아마존 EC2 는 아마존이 가지는 방대한 서버팜에 사용자의 프로그램을 돌려서 결과를 돌려주는 방식으로 엄청난 수의 고객들을 받아들이고 있다. 구글 같은 경우는 자체적인 웹솔루션으로 이미 구글앱스를 만들어 운영하고 있다.

내가 보는 안드로이드의 강력함은, 다양한 기기에 충분히 흡수되어, 궁극적으로 구글앱스를 돌릴 수 있는 뛰어난 클라이언트 플랫폼 시장을 열어줄 수 있는데 있다.  물론 다른 다양한 회사에 기회가 될 수 있겠지만, 가장 대표적인 주자는 구글앱스가 될 것이라고 본다. 그렇다면 이때의 파괴력은 과거와는 상상도 할 수 없을정도가 될 것이라고 본다.

윈도시리즈에서 가장 아쉬운 점은, 그들이 웹과의 생태계 연결을 너무 안이하게 생가가하지않았나 하는 점이다. 윈도는 IE와의 연결을 통해서 놀라울정도로 상호작용에 뛰어난 면모를 보였다. 지금은 잘 쓰이지 않는 액티브 데스크탑같은 기술은, 제대로된 기술적인 진화만 있었다면, 엄청난 폭발력을 가지는 잠재력이 있을 수 있었다. 간단한 위젯을 넘어, 액티브 데스크탑을 공유공간으로 삼아 각종 파일과 데이터를 저장하고, 이를 Live.com과 연결해서 데스크탑 검색같은 기능을 추가하고... 이런식으로 PC의 한계를 뛰어넘어 방대한 네트웍 공간을 가상 PC로 할수만 있었다면, 엄청난 신세계를 열 수 있었지않았나 생각한다.

참 아쉽다. 방향을 너무 여러곳으로 찍어서, 오도 가도 못하는 뚱뚱한 괴물이 되어버린 MS를 보자니, 80년대 삽질 대마왕이었던 IBM이 생각난다.

Google Chrome 이후로 자바스크립트에 많은 관심이 간다.
그중에 하나가 브라우저 상에서의 애니메이션을 제어하는 기술이다.
HTML 5 상에서의 CANVAS로 수행하는 상당히 많은 예제를 보고 있자면 실제로 사용이 가능한 경우가 상당히 많을 것으로 생각한다.
오늘자 Slashdot에서는 플래시 없이 동영상을 VIDEO태그로 실행하는 사이트가 올라왔다. Firefox 3.5 에서만 볼 수 있는 것이 아쉽지만, 앞으로 HTML 5 가 플러그인 시장에 얼마나 엄청난 타격을 입힐지는 기대가 된다.

말하자면 컴퓨터쪽에서의 강력한 연산기능대신 비디오/오디오 등에 특화된 CPU가 있다면, 서버쪽에서 대부분의 연산을 담당하고 클라이언트에서는 웹브라우저가 실제 플랫폼을 대신하는 상황도 생각할 수 있다.

Erlang , LISP으로 만든 게임에서 플레이어 DB데이터와 게임액션을 Erlang이 담당하고, 게임상의 상태처리, 길찾기, API등을 Lisp으로 처리하는 방식은 상당히 좋은 Role Model이 될 수 있을듯하다.

ARM등의 비디오/오디오 강화 CPU에 실연산처리는 클라우드를 포함하는 대규모 서버군이 처리하고, 광대역 처리만 제대로 된다면 기존의 플러그인없이도 HTML 5 만으로도 훌륭한 게임이 나올 수 있을 듯하다.

---

관련링크

• Neuroarena - multiplayer online realtime stratege
• NihilogicLabs의 자바스크립트 마리오 카트
• ypsilon Scheme 구현
• Scheme등으로 게임을 제작하는 회사 Gamerizon
• Clean으로 구성한 게임
• HTML5 비디오 데모 사이트
  

이제 각 방별로 해당 방에 들어갔을때 설명을 출력하도록 한다.

;;;; 게임의 Castle 구성하기..
;;; north south east west up down mobs
(defvar *castle*
  '((0 2 0 0 0 0 0 ("You are in the hall way." "There is a door in south." "Through window to the north you can see secret herb garden"))
    (1 3 3 3 0 0 0 ("This is the audience chamber" "There is a window to the south. By looking to the right" "Through it you can see the entrance of the castle" "Doors leave this room to the north, east, and south" ))
    (2 0 5 2 0 0 0 ("You are in great hall, all-shaped room" "There is doors to the east and to the north" "In the alcove is a door to the west"))
    (0 5 0 0 0 0 0 ("This is the monarch's private meeting room" "There is a single exit to the south"))
    (4 0 0 3 15 13 0 ("This inner hallway contains a door to the north." "And one to the west, and a circular stairwell" "passes though the room" "You can see ornamental lake through here"))
    (0 0 1 0 0 0 0 ("You are at the entrance to a fobidding-looking" "stone castle. You are facing east"))
    (0 8 0 0 0 0 0 ("This is castle's kitchen. Though windows in" "The north wall you can see secret herb garden." "A door leave the kitchen to the south" ))
    (7 10 0 0 0 0 0 ("You are in store room admist spices" "vegatables, and vast sacks of floud and" "Other provisions. There is a door to the north" "and one to the south"))
    (0 19 0 8 0 8 0 ("You are slowly descends."))
    (8 0 11 0 0 0 0 ("You are in the real vestibule." "There are windows to the south from which" "you can see ornamental lake" "There is an exit to the east and " "one to north"))
    (0 0 10 0 0 0 0 () )
    (0 0 0 13 0 0 0 ("you are in dank dark dungeon" "There is single exit, a small hole in" "wall towards to east"))
    (0 0 12 0 5 0 0 ("You are in the prison guardroom in the " "basement of the castle. The staiwell" "ends in the room. There is one other" "exit, a small hole in the east wall") )
    (0 15 17 0 0 0 0 ("You are in the master bedroom on the upper" "level of the castle..." "Looking down from the window to the west, you" "can see the entrance to the castle, while the" "secret herb garden is visible below to the north" "window. There are doors to the east and" "to the south"))
    (14 0 0 0 0 5 0 ("This is L-shaped upper hallway." "To the north is a door, and there is a strairwell in the hall as well. You can see" "the lake through the south windows."))
    (17 0 19 0 0 0 0 ("This room was used as the castle treasury in" "by-gone years..." "There are no windows, just exits to the" "north and to the east"))
    (18 16 0 14 0 0 0 ("Ooooh.. you are in the chembermaids' bedroom" "There is an exit to the west and a door " "TO the south"))
    (0 17 0 0 0 0 0 ("This tiny room on the upper level is the" "dressing chamber. There is a window to the" "north. with a view of the here garden down" "below. A door leaves to the south."))
    (9 0 16 0 0 0 0 ("This is a small room outside the castle" "lift which can be entered by a door to the north" "another door leads to the west, you can see" "the lake through the southern windows"))))

설명을 출력할 부분을 만든다.

먼저 방에서 각 요소를 가져오는 함수에, 새로 설명을 출력할 부분을 추가한다.

;;; 방의 리스트에서 각 요소를 가져오는 함수
(defun get-rooms-element (room element)
  (cond ((char= element #\n) (car room))
        ((char= element #\s) (nth 1 room))
        ((char= element #\e) (nth 2 room))
        ((char= element #\w) (nth 3 room))
        ((char= element #\u) (nth 4 room))
        ((char= element #\d) (nth 5 room))
        ((char= element #\m) (nth 6 room))
        ((char= element #\v) (nth 7 room))
        (t
         nil)))

다음으로 해당하는 방의 설명을 출력하는 함수를 만든다.

;;; 방의 모습을 설명하는 루틴
(defun describe-room ()
  (format t "The room is ~A~%" *room*)
  (print-room *room*)
  (if (= *room* 9) (setf *room* 10)))

9번방에 들어온 경우에는 자동으로 10번방으로 이동한다.

;;; 방의 내역을 출력하기
(defun print-room (which-room)
  (let ((desc-list (get-rooms-element (get-room which-room ) #\v)))
    (labels ((iter (field)
               (cond ((null field) )
                     (t
                      (format t "~a~%" (car field))
                      (iter (cdr field))))))
      (iter desc-list))))

마지막으로 플레이어가 11번방으로 들어왔다면 게임을 종료한다.

;;; 전체 이벤트 루프

(defun event-loop ()
  (let ((k (get-rooms-element (get-room *room*) #\m))
        (game-over nil))
    (loop
       (status-report)
       (cond ((= *room* 11)
              (progn
                (format t "Congratulation, you escape the castle")
                (setf game-over t)))
             (t
              (let ((input-key (keyboard-event)))
                (cond ((string= input-key "n") (go-direction #\n))
                      ((string= input-key "s") (go-direction #\s))
                      ((string= input-key "e") (go-direction #\e))
                      ((string= input-key "w") (go-direction #\w))
                      ((string= input-key "u") (go-direction #\u))
                      ((string= input-key "d") (go-direction #\d))
                      ((string= input-key "c") (consume-food))
                      ((string= input-key "f") (fight))
                      ((string= input-key "r") (runaway))
                      ((string= input-key "q") (setf game-over t))
                      ((string= input-key "m") (magic-amulet))
                      ((string= input-key "p") (picking-up))
                      ((string= input-key "i") (inventory))))))
       (if (eq game-over t)
           (return-from event-loop)))))

다음 부터는 완성된 버전을 LISP식으로 조금씩 변화시켜나가보도록 하겠다.

전투 모듈에서는 몹에 대한 공격과 방어가 확률에 의해 진행된다.
방어구를 입은 경우 넘겨야할 난이도를 75%정도로 낮추어서 게임 진행을 쉽게 한다.

;;; 전투모듈
(defun fight ()
  (prompt-read "press return to fight")
  (cond ((= *suit* 1)
         (progn
           (format t "Your armor increases your chance of success~%")
           (setf *ff* (* 3 (floor (/ *ff* 4)))))))
  (cond ((and (= *axe* 0) (= *sword* 0))
         (progn
           (format t "You have no weapons~%You mush fight with Base hands~%")
           (setf *ff* (+ *ff* (floor (/ *ff* 5))))))
        ((and (= *axe* 1) (= *sword* 0))
         (progn
           (format t "You have only an axe to fight with~%")
           (setf *ff* (* 4 (floor (/ *ff* 5))))))
        ((and (= *sword* 1) (= *axe* 0))
         (progn
           (format t "You mush fight with your sowrd~%")
           (setf *ff* (* 3 (floor (/ *ff* 4))))))
        (t
         (let ((z (parse-integer (prompt-read "Which weapon? 1- Axe, 2- Sword"))))
           (cond ((= z 1) (setf *ff* (* 4 (floor (/ *ff* 5)))))
                 ((= z 2) (setf *ff* (* 3 (floor (/ *ff* 4)))))))))
  (taking-arms))

실제 전투모드에서는 확률에 의거해 공방을 결정하고, 전투가 끝나는 것도 확률로 결정한다.
전투종료시 난이도 값을 얼마나 남겼는지를 확인해서 승패를 결정한다.

;; 배틀모드
(defun taking-arms ()
  (let ((prob1 (random 10))
        (prob2 (random 10))
        (prob3 (random 10))
        (prob4 (random 100))
        (prob5 (random 10)))
    (cond ((> prob1 5)
           (format t "~a attacks~%" *monster*))
          (t
           (format t "you attack~%")))
    (cond ((> prob2 5)
           (progn
             (format t "You manage to wound it~%")
             (setf *ff* (floor (* 5 (/ *ff* 6)))))))
    (cond ((> prob3 5)
           (progn
             (format t "The monster wounds you!~%")
             (decf *strength* 5))))
    (cond ((> prob4 35)
           (taking-arms))
          (t
           (cond ((> (* prob5 1.6) *ff*)
                  (progn
                    (format t "~%and you managed  to kill the ~a" *monster*)
                    (incf *mk*)
                    (setf (nth 6 (nth (- *room* 1) *castle*)) 0)))
                 (t
                  (progn
                    (format t "The ~a defeated you." *monster*)
                    (setf *strength* (floor (*strength* 2))))))))))

여기서 만들게 될 함수들은 상점, 음식먹기 등에 해당한다.
먼저 지난번에 만들었던 Event Loop를 살짝 수정했다.

(defun event-loop ()
  (let ((k (get-rooms-element (get-room *room*) #\m))
        (game-over nil))
    (loop
       (status-report)
       (let ((input-key (keyboard-event)))
         (cond ((string= input-key "n") (go-direction #\n))
               ((string= input-key "s") (go-direction #\s))
               ((string= input-key "e") (go-direction #\e))
               ((string= input-key "w") (go-direction #\w))
               ((string= input-key "u") (go-direction #\u))
               ((string= input-key "d") (go-direction #\d))
               ((string= input-key "c") (consume-food))
               ((string= input-key "f") (fight))
               ((string= input-key "r") (runaway))
               ((string= input-key "q") (setf game-over t))
               ((string= input-key "m") (magic-amulet))
               ((string= input-key "p") (picking-up))
               ((string= input-key "i") (inventory))))
       (if (eq game-over t)
           (return-from event-loop)))))

마법 아뮬렛이 있을때 수행할 함수를 만든다.

;;; 마법 아뮬렛을 사용할 때 수행할 곳(6번과 11번은 제외 )
(defun magic-amulet ()
  (let ((ro (+ (random 19) 1)))
    (cond ((or (= ro 6) (= ro 11)) (magic-amulet))
          (t
           (setf *room* ro)))))

또한 음식을 먹는 함수를 만든다.

;;; 음식 먹기
(defun consume-food ()
  (cond ((>= food 1)
         (progn
           (format t "You have ~a units of food~%" *food*)
           (format t "How many do you want to eat? :")
           (let ((z (parse-integer (read-line))))
             (if (> z food)
                 (consume-food)
                 (progn
                   (decf *food* z)
                   (incf *strength* (* 5 z)))))))))

이제 방에 보물이 있는 경우 집는 함수를 만든다.

;;; 방의 물건 집기
(defun picking-up ()
  (let ((treasure (get-rooms-element
                   (get-room *room*)
                    #\m)))
    (if (< treasure 10)
        (format t "There is no treasure to pickup")
        (progn
          (incf *wealth* treasure)
          (setf (nth 6 (nth (- *room* 1) *castle*)) 0)))))

마지막으로 상점에서 물건을 구입하는 함수를 만든다.

;;; Show shop
(defun show-shop ()
  (format t "You can buy 1 - Flamming Torch ($15)~%")
  (format t "            2 - Axe ($10)~%")
  (format t "            3 - Sword ($20)~%")
  (format t "            4 - Food ($2 per unit)~%")
  (format t "            5 - Magic of Amulet ($30)~%")
  (format t "            6 - Suit of Armor ($50)~%")
  (format t "            0 - To continue Adventure ~%"))

;;; Shop에서 물건사기
(defun inventory ()
  (format t "Provision & Inventory~%")
  (cond ((> *wealth* 0)
         (progn
           (show-shop)
           (let ((z (parse-integer (prompt-read "Enter no of item:"))))
             (cond ((= z 1)
                    (progn
                      (setf *light* 1)
                      (decf *wealth* 15)))
                   ((= z 2)
                    (progn
                      (setf *axe* 1)
                      (decf *wealth* 10)))
                   ((= z 3)
                    (progn
                      (setf *sword* 1)
                      (decf *wealth* 20)))
                   ((= z 4)
                    (progn
                      (let ((q (prompt-read "how many food do you want")))
                        (cond ((> (* q 2) *wealth*)
                               (format t "You Can't Get enough money"))
                              (t
                               (progn
                                 (incf *food* q)
                                 (defc *wealth* (* q 2))))))))
                   ((= z 5)
                    (progn
                      (setf *amulet* 1)
                      (decf *wealth* 30)))
                   ((= z 6)
                    (progn
                      (setf *armor* 1)
                      (decf *wealth* 50)))))))
        (t
         (format t "You have no money~%"))))

일단 기본적인 툴이 모두 마련되었다.
다음장에서는 전투에 대한 부분을 살펴보자.

What made those old, 2D platformers so great?를 대충 정리해보면..

1. 조작
   
2. 레벨 디자인
3. 상태

등을 들 수 있다.

---

조작
조작은 플레이어에 부여하는 모든 능력과 속성을 의미한다. 달리기나, 점프, 스핀대시같은 다양한 이동방법부터 일시적인 무적상태같은 특이상황을 모두 아우른다.

좋은 조작식이란 간결하고 명확해야한다. 최대한 직관적으로 설계해야하며, 사용자에게 혼동을 줄 수 있는 요소는 최대한 배제해야한다. 예를 들어, 게임중에 오브젝트와 충돌하는 경우,  아이템의 경우에는 습득이 되어야하며, 적과의 경우라면 피해를 입게해야한다. 아이템을 얻는데 필요이상의 동작이 필요하거나, 적과의 충돌을 애매하게 판정해서는 안된다.

이러한 기본 가정하에서 사용자와의 인터페이스를 구성할 수 있다.

좋은 조작법이란 현실에서 보기힘든 빠르고, 정교한 움직임을 보임으로서, 사용자의 동기를 유발할 수 있어야한다. 하지만 본질적인 흥미는 레벨디자인과의 조화에서 얻을 수 있어야한다.

레벨 디자인
게임을 고유한 외양을 지니는 개별적인 지역으로 구성함으로써, 상당한 효과를 얻을 수 있다. 또한, 상호작용적인 요소를 배치하여, 이러한 특징을 부각시킬 수 있다. 하지만, 이러한 요소는 종종, 부조화를 일으킬 수 있기 때문에 사용에 주의를 해야한다.
사소한 문제같지만, 적절히 규제되지 않는다면 사용자가 혼동을 일으킬 수 있다.

배경과 동시에, 게임의 레벨은 다양한 플랫폼으로 구성되어있다. 사다리, 미끄럼틀, 순간 이동장치, 계단, 입구같은 요소가 그것이다. 이런 요소는 게이머가 실제로 게임을 진행하는 지역이기때문에, 그 메커니즘을 명확하고 분명하게 이해할 수 있어야한다. 이 부분에서 조작성과의 조화가 이루어져야한다.

좋은 플레이 공간은 플레이어를 다양한 능력을 사용할 수 있도록 끌어당긴다. 기존에 존재하는 다양한 요소를 십분 이용하도록 유도하거나 어느 정도 강제할 정도가 되어야한다.

특정 지역을 들어가거나 떠나도록 하는 요소를 분명하게 알려주는 것 역시 큰 도움이 된다. 게임상에 수집해야할 요소를 경로에 따라 배치함으로서 게이머가 길을 잃지 않도록 배려할 수 있으며, 이를 통해 게임은 더 쉽고, 즐기기에 편안하게 된다.

상태
다음의 씬을 상상해보자: 캐릭터가 막 점프를 했다. 적은 캐릭터를 노리고, 미사일을 벽에대고 쏘았고, 벽을 파괴시켰다. 이런 씬에서 몇가지 상태를 찾을 수 있다: 점프, 추적, 발사, 파괴가 그것이다.

상태는 게임상의 물체의 행동과 속성에 붙는 일련의 논리적인 단위의 명명이라고 할 수 있다. 이를 통해 적과 보스의 핵심적인 인공지능과, 플레이어가 이를 파악하고 패턴을 깨는 행위를 표준화 할 수 있다. 게임상의 몹과 요소에 다양한 개성을 부여함으로서, 이에 대항하는데 여러가지 기법을 사용하도록 부추킬 수 있다.

또한 이러한 메커니즘을 효율적으로 배치한다면 상당한 리플레이성을 부여할 수 있으며, 타임어택같은 하드코어적인 시도록 할 수 있는 고난이도의 플레이역시 가능케할 수 있다.

그냥..

(reverse "hello") -> "olleh"

임..

쩝.. 좀 긴 버전..

(defun string-reverse (str)
  (let ((strlen (length str)))
    (cond ((= strlen 0) str)
          ((= strlen 1) str)
          (t
           (string-concat (string (aref str (- strlen 1)))
                          (string-reverse (subseq str 0 (- strlen 1))))))))

iteration 버전?

(defun string-rev (str)
  (labels ((iter (src tar)
             (let ((strlen (length tar)))
               (cond ((= (length tar) 0) src)
                     (t
                      (iter (string-concat src (string (aref tar (- strlen 1))))
                            (subseq tar 0 (- strlen 1))))))))

머 C로 짤줄은 알지만.. 난 LISP을 사랑하니깐..

이번장에서는 실제로 키보드 입력을 받아들이고 게임을 구성하는 루프를 만든다.
먼저 키보드 입력을 받아들여보자.

;;; 사용자 키보드 입력을 체크하고 그에따란 이벤트 처리를 함
(defun keyboard-event ()
  (format t "What do you want to do:")
  (let ((k (read-line)))
    (if (= (length k) 1)
        k
        (keyboard-event))))

다음으로 이벤트 루프를 구성한다.

;;; 전체 이벤트 루프

(defun event-loop ()
  (let ((k (get-rooms-element (get-room *room*) #\m))
        (game-over nil))
    (loop
       (status-report)
       (let ((input-key (keyboard-event)))
         (cond ((string= input-key "n") (go-direction #\n))
               ((string= input-key "s") (go-direction #\s))
               ((string= input-key "e") (go-direction #\e))
               ((string= input-key "w") (go-direction #\w))
               ((string= input-key "c") (consume-food))
               ((string= input-key "f") (fight))
               ((string= input-key "r") (runaway))
               ((string= input-key "q") (setf game-over t))
               ((string= input-key "i") (inventory))))
       (if (eq game-over t)
           (return-from event-loop)))))

구성된 이벤트 루프를 토대로 해당하는 방으로 이동하는 함수를 만들고, 나머지 모든 부분을 연결하는 게임함수를 만든다.

;;; 해당 방의 방위로 이동하는 함수
(defun go-direction (direction)
  (let ((door (get-rooms-element (get-room *room*) direction)))
    (cond ((= door 0) (format t "There is no door in that direction."))
          (t
           (setf *room* door)))))
 
;;; 실제 게임 실행부분
(defun run-game ()
  ;;; 게임 초기화
  (reset-mobs)
  (init-var)
  (get-player-name)
  (put-gold 4)
  (put-mob 4)
  (set-init-treasure)
  (event-loop))

이제 슬슬 기본틀을 완성된 것 같고.. 음식과 전투, 도망가기, 인벤토리등을 구성하도록 하자.

한겨레 21:  2등은 어떻게 살아남는가를 읽고 나서 아웃사이더로 일하는 내가 생각해봐야할 글이라고 생각한다.

원 글에서는 대항마 전략과 체계화 전략을 말해주면서 실제 펩시와 에이비스라는 업계 2위의 업체를 예로 들어 설명했었다. 여기에 내가 생각하는 OS에서의 리눅스, 프로그래밍 언어에서의 LISP을 생각해보았다.

사실 리눅스 커뮤니티는 오랜동안 윈도를 넘어야한다는 일종의 강박관념을 쥐고 있는 것 같다. 더 적은 리소스, 더 많은 자유, 더 많은 xxx.. 라는 끝도 없는 우월성을 주장하지만 내가 볼 때 가장 먼저 해야할 것은 스스로 한계를 인정해야한다는 사실이다.
이미 사회에서의 1위는 윈도로 결정이 난 상태이다. 그렇다면, 윈도를 1위로 인정하고 2위로서 1위와 연결하는 전략을 세워야하는 것이 더 적당하다고 본다. 과감하게 2등(현재는 맥에 빌려 3등일지도 모르지만)임을 선언함으로서, 윈도를 분명한 1위 대상으로 인지시키만 (이미 많은 사람들이 공식, 비공식적으로 인정하는 바이다) 자신을 1위와 함께 갈 수 있는 2위로서 자리를 잡는 것이 중요하다고 본다.

예를 들어, 다양한 개발툴을 무료로 쓸 수 있다거나, 서버 테스트 베드로서 아주 훌륭하게 역할을 취할 수 있다거나 하는 점이다. 클라이언트로서는 윈도, 보조툴로 리눅스라는 레벨을 진행한다면 나름 괜찮은 성공을 할 수 있을 것 같다. 이미 집집마다 2~3대의 PC가 기본이 되고 있는 상황에서, mp3나 동영상을 보관할 수 있는 보조적인 부분을 장악한다면 충분한 점유율을 만들 수 있을 것으로 본다.

첫번째 PC는 윈도, 그리고 데이터 보관은 리눅스.. 이런 식으로 대항마 전략을 이끈다면 실제 사람들은 편리하고 간단한 작업은 윈도, 안전하고 신뢰할 수 있는 리눅스라는 식으로 진행한다면 상당한 효과를 줄 수 있을 것이라고 생각한다.

LISP역시 C/C++만큼 속도를 낼 수 있다.. 이런 식의 진부한 강조점을 버리고, C/C++/Java등이 분명한 1위임을 인정하고, 가지고 있는 강점 - 놀라운 추상화 능력이나, 과거에 쌓아두었던 수많은 AI 요소들 - 을 기반으로 협동플레이를 할 수 있다면, 훌륭한 2위자리로 올라설 수 있으리라고 생각한다.

체계화 전략에서 승부가 갈린 것은 웹에서의 Perl > PHP > Ruby로 이어지는 패러다임의 변화라고 생각한다. 초창기 CGI 패러다임에서 최고의 위치를 자랑하던 Perl을, 간단하고 쉬운 웹 어플리케이션이라는 체계를 완성함으로서 PHP가 끌어내렸고, Rail이라는 걸출한 프레임워크를 무기로 Ruby가 그 자리를 위협하는 것이 좋은 예라고 생각한다.

갈길은 멀다. 아웃사이더중의 아웃사이더 일 (리눅스에서 LISP으로 개발함.. ㅠ.ㅠ)을 계속하고 있지만, 이런 전략을 꾸준히 세워나가면 언젠가 찬란한 2위로 등극할 수 있으리라 생각한다.