Project Avalon Online(Game) Final Report
-
Upload
ikwhan-chang -
Category
Entertainment & Humor
-
view
733 -
download
3
description
Transcript of Project Avalon Online(Game) Final Report
College����������� ������������������ Computer����������� ������������������ Science����������� ������������������ and����������� ������������������ Technology����������� ������������������
Class����������� ������������������ 컴퓨터����������� ������������������ 프로그램����������� ������������������ 설계����������� ������������������ Professor����������� ������������������ Cho����������� ������������������ Sung-Rae����������� ������������������
Team����������� ������������������ Name����������� ������������������ Avalon����������� ������������������ A+����������� ������������������ Due����������� ������������������ Date����������� ������������������ 2012.06.13����������� ������������������
Team����������� ������������������ Members����������� ������������������
20060957����������� ������������������ 장익환����������� ������������������ Server����������� ������������������
20112609����������� ������������������ 김성진����������� ������������������ Client����������� ������������������
20110483����������� ������������������ 강수현����������� ������������������ UI/Testing/Document����������� ������������������
20114514����������� ������������������ 서왕덕����������� ������������������ Client(Logic)����������� ������������������
20114509����������� ������������������ 황정윤����������� ������������������ UI/Testing/Document����������� ������������������
Project����������� ������������������ 아발론����������� ������������������ 2D����������� ������������������ 소셜����������� ������������������ 온라인����������� ������������������ 게임����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
Final����������� ������������������ Report����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
Program����������� ������������������ Description����������� ������������������
Final Report
1
����������� ������������������
아발론����������� ������������������ 온라인이란����������� ������������������ 보드게임의����������� ������������������ 종류����������� ������������������ 중����������� ������������������ 하나입니다.����������� ������������������ 저희����������� ������������������ 팀은����������� ������������������ 이����������� ������������������ 게임의����������� ������������������
단순하면서����������� ������������������ 중독성����������� ������������������ 강한����������� ������������������ 로직에����������� ������������������ 흥미를����������� ������������������ 느껴서����������� ������������������ 이를����������� ������������������ 2D로����������� ������������������ 개발하기로����������� ������������������
하였습니다.����������� ������������������ 넷마블����������� ������������������ 등의����������� ������������������ 일반적인����������� ������������������ 온라인����������� ������������������ 게임과����������� ������������������ 같이����������� ������������������ 대전모드를����������� ������������������ 제공하고����������� ������������������
멀티플레이가����������� ������������������ 가능한����������� ������������������ 보드����������� ������������������ 게임을����������� ������������������ 제작하기로����������� ������������������ 하였습니다.����������� ������������������ 프로젝트를����������� ������������������ 단순한����������� ������������������
프로젝트로����������� ������������������ 끝내는����������� ������������������ 것이����������� ������������������ 아니라,����������� ������������������ 최근����������� ������������������ 추세에����������� ������������������ 따라����������� ������������������ 소셜����������� ������������������ 네트워크����������� ������������������ 기능����������� ������������������ 특히����������� ������������������
페이스북����������� ������������������ 로그인����������� ������������������ 및����������� ������������������ 소셜����������� ������������������ 기능을����������� ������������������ 접목시켜����������� ������������������ SNG(Social����������� ������������������ Network����������� ������������������ Game,����������� ������������������
SNS 를����������� ������������������ 기반으로����������� ������������������ 하는����������� ������������������ 소셜����������� ������������������ 네트워크����������� ������������������ 게임)����������� ������������������ 라는����������� ������������������ 장르로����������� ������������������ 본����������� ������������������ 게임을����������� ������������������
개발하였습니다.����������� ������������������
����������� ������������������ ����������� ������������������
Final Report
2
Schedule����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������
기획
• 게임 룰 벤치마킹 • 사용할 라이브러리 서칭 • Balsamiq을 사용한 Window 기획
디자인
• 포토샵을 사용한 디자인 • NetBeans를 사용한 Swing 라이브러리 배치
Client 개발
• Eclipse / SVN을 사용한 게임 개발 • MVC 모델 개발
Server 개발
• Echo Server 개발 • 패킷 설계/직렬화
테스트
• JUnit 단위테스트 • 서버 부하 테스트
Final Report
3
Game����������� ������������������ Role����������� ������������������
1) Main����������� ������������������ Role����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������ ����������� ������������������
Final Report
4
2) Role����������� ������������������ –����������� ������������������ 1����������� ������������������
����������� ������������������
3) Role����������� ������������������ –����������� ������������������ 2����������� ������������������
����������� ������������������
����������� ������������������ ����������� ������������������
Final Report
5
Member’s����������� ������������������ Role����������� ������������������
이름����������� ������������������ 역할����������� ������������������
김성진����������� ������������������ Team����������� ������������������ Leader,����������� ������������������ PM,����������� ������������������ Client����������� ������������������
서왕덕����������� ������������������ Program����������� ������������������ Design,����������� ������������������ Logic����������� ������������������
장익환����������� ������������������ Social,����������� ������������������ Server����������� ������������������
강수현����������� ������������������ Program����������� ������������������ Architecting����������� ������������������
UI����������� ������������������ Design����������� ������������������ (using����������� ������������������ NetBeans)����������� ������������������
황정윤����������� ������������������
Resource����������� ������������������ Searching����������� ������������������
UI����������� ������������������ Design����������� ������������������ (using����������� ������������������ Photoshop,NetBeans)����������� ������������������
Testing����������� ������������������
����������� ������������������
Project����������� ������������������ Features����������� ������������������
Socialization����������� ������������������ /����������� ������������������ Native����������� ������������������ Application����������� ������������������
저희����������� ������������������ 프로그램의����������� ������������������ 가장����������� ������������������ 큰����������� ������������������ 특징은����������� ������������������ 페이스북����������� ������������������ 연동입니다.����������� ������������������ 페이스북����������� ������������������ 연동����������� ������������������ 과정은����������� ������������������ 먼저����������� ������������������
페이스북����������� ������������������ 앱을����������� ������������������ 개발자����������� ������������������ 사이트(http://developer.facebook.com)에서����������� ������������������ 등록하고����������� ������������������
사용하게����������� ������������������ 됩니다.����������� ������������������
����������� ������������������ 위는����������� ������������������ 저희����������� ������������������ 아발론����������� ������������������ 온라인을����������� ������������������ 등록한����������� ������������������ 화면입니다.����������� ������������������ 그리고����������� ������������������ 전체적인����������� ������������������ 유저에����������� ������������������ 대한����������� ������������������ 처리는����������� ������������������
토큰으로����������� ������������������ 이뤄지는데,����������� ������������������ 이는����������� ������������������ 페이스북의����������� ������������������ OAuth(Open����������� ������������������ Authorization)����������� ������������������ 에����������� ������������������ 의해서����������� ������������������
토큰을����������� ������������������ 부여밭을����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������
Final Report
6
����������� ������������������ 위����������� ������������������ 그림과����������� ������������������ 같이����������� ������������������ OAuth 연동을����������� ������������������ 위해서는����������� ������������������ 페이스북의����������� ������������������ 서버를����������� ������������������ Session 을����������� ������������������ 통해����������� ������������������ 한번����������� ������������������
거쳐와야����������� ������������������ 합니다.����������� ������������������ 이를����������� ������������������ 위해서는����������� ������������������ 브라우저를����������� ������������������ 직/간접적으로����������� ������������������ 사용해야����������� ������������������ 하는데,����������� ������������������ 이를����������� ������������������
위해����������� ������������������ Apache 에서����������� ������������������ 제공하는����������� ������������������ HttpClient����������� ������������������ 를����������� ������������������ 사용해야����������� ������������������ 합니다.����������� ������������������
저희는����������� ������������������ Apache����������� ������������������ HttpClient 를����������� ������������������ 사용하는����������� ������������������ 과정이����������� ������������������ 너무나도����������� ������������������ 복잡하고����������� ������������������ 그렇게����������� ������������������ 할����������� ������������������
바에는����������� ������������������ 차라리����������� ������������������ 웹����������� ������������������ 기반으로����������� ������������������ 개발하는����������� ������������������ 것이����������� ������������������ 낫다����������� ������������������ 판단하여,����������� ������������������ JSP 를����������� ������������������ 통해����������� ������������������ 간단한����������� ������������������
OAuth 인증����������� ������������������ 프로그램을����������� ������������������ 만들었습니다.����������� ������������������
소스)����������� ������������������ 서버����������� ������������������ 인증����������� ������������������ 처리����������� ������������������ JSP 소스����������� ������������������ 일부����������� ������������������ (http://changikhwan.com/fb/step1.jsp)����������� ������������������
<%@����������� ������������������ page����������� ������������������ language="java"����������� ������������������ import="java.util.*,java.sql.*"����������� ������������������ session="true"����������� ������������������
contentType="text/html;����������� ������������������ charset=EUC-KR"����������� ������������������ pageEncoding="EUC-KR"%>����������� ������������������
<%����������� ������������������
����������� ������������������ String����������� ������������������ appKey����������� ������������������ ����������� ������������������ ����������� ������������������ =����������� ������������������ "441977459148425";����������� ������������������
����������� ������������������ String����������� ������������������ appSecret����������� ������������������ ����������� ������������������ =����������� ������������������ "865a7e5d19faf56eb71f9810a71bc5ed";����������� ������������������
����������� ������������������ String����������� ������������������ token����������� ������������������ =����������� ������������������ request.getParameter("token");����������� ������������������
����������� ������������������ ����������� ������������������
����������� ������������������ String����������� ������������������ url����������� ������������������ =����������� ������������������ "http://www.facebook.com/dialog/oauth?client_id="+����������� ������������������
����������� ������������������
����������� ������������������ appKey+"&redirect_uri=http://avalon.changikhwan.com:9090/fb/step2.jsp&scope=publis
h_stream,offline_access";����������� ������������������
����������� ������������������ ����������� ������������������ %>����������� ������������������
����������� ������������������
하지만����������� ������������������ J2SE����������� ������������������ 방식으로����������� ������������������ 개발된����������� ������������������ 프로그램에서는����������� ������������������ 현재까지����������� ������������������ 웹����������� ������������������ 브라우저를����������� ������������������ UI 상으로����������� ������������������
구현할����������� ������������������ 수����������� ������������������ 있는����������� ������������������ 방법은����������� ������������������ 없습니다.����������� ������������������ Oracle 에서����������� ������������������ 이러한����������� ������������������ 부분을����������� ������������������ 전부����������� ������������������ Java����������� ������������������ FX(Flash 나����������� ������������������
Silverlight 와����������� ������������������ 같은����������� ������������������ RIA 프로그램)����������� ������������������ 에서����������� ������������������ 개발����������� ������������������ 가능하도록����������� ������������������ 하였기����������� ������������������ 때문입니다����������� ������������������
이에����������� ������������������ 저희가����������� ������������������ 찾은����������� ������������������ 해결책은����������� ������������������ The����������� ������������������ DJ����������� ������������������ Project 에서����������� ������������������ 만든����������� ������������������ Swing����������� ������������������ Native����������� ������������������ Library 를����������� ������������������
사용하면����������� ������������������ SWT(Standard����������� ������������������ Widget����������� ������������������ Toolkit)을����������� ������������������ 거쳐����������� ������������������ 현재����������� ������������������ 사용자의����������� ������������������ 기본����������� ������������������ 브라우저를����������� ������������������
띄울����������� ������������������ 수����������� ������������������ 있도록����������� ������������������ 하였습니다.����������� ������������������
소스)����������� ������������������ Swing����������� ������������������ Native����������� ������������������ Library����������� ������������������ 처리����������� ������������������ 부분(GetAccessToken.java)����������� ������������������
Final Report
7
public����������� ������������������ class����������� ������������������ GetAccessToken����������� ������������������ extends����������� ������������������ JPanel����������� ������������������ {����������� ������������������
����������� ������������������ private����������� ������������������ static����������� ������������������ JFrame����������� ������������������ upperFrame;����������� ������������������
����������� ������������������ private����������� ������������������ UIThread����������� ������������������ thread;����������� ������������������
����������� ������������������ private����������� ������������������ static����������� ������������������ String����������� ������������������ ACCESS_TOKEN����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ JPanel����������� ������������������ webBrowserPanel����������� ������������������ =����������� ������������������ new����������� ������������������ JPanel(new����������� ������������������ BorderLayout());����������� ������������������
����������� ������������������ ����������� ������������������ public����������� ������������������ GetAccessToken(final����������� ������������������ JFrame����������� ������������������ frame,final����������� ������������������ UIThread����������� ������������������ tClient)����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ super(new����������� ������������������ BorderLayout());����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ upperFrame����������� ������������������ =����������� ������������������ frame;����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ thread����������� ������������������ =����������� ������������������ tClient;����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //webBrowserPanel.setBorder(BorderFactory.createTitledBorder("Native����������� ������������������ Web����������� ������������������ Browser����������� ������������������
component"));����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ final����������� ������������������ JWebBrowser����������� ������������������ webBrowser����������� ������������������ =����������� ������������������ new����������� ������������������ JWebBrowser();����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ webBrowser.navigate("http://avalon.changikhwan.com:9090/fb/step1.jsp");����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ webBrowser.setStatusBarVisible(false);����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ webBrowserPanel.add(webBrowser,����������� ������������������ BorderLayout.CENTER);����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ add(webBrowserPanel,����������� ������������������ BorderLayout.CENTER);����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //����������� ������������������ Create����������� ������������������ an����������� ������������������ additional����������� ������������������ bar����������� ������������������ allowing����������� ������������������ to����������� ������������������ show/hide����������� ������������������ the����������� ������������������ menu����������� ������������������ bar����������� ������������������ of����������� ������������������ the����������� ������������������ web����������� ������������������ browser.����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ webBrowser.setMenuBarVisible(false);����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ webBrowser.registerFunction(new����������� ������������������ WebBrowserFunction("testFunc")����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ @Override����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ public����������� ������������������ Object����������� ������������������ invoke(JWebBrowser����������� ������������������ webBrowser,����������� ������������������ Object...����������� ������������������ args)����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //System.out.println(args[0].toString());����������� ������������������ //����������� ������������������ FACEBOOK����������� ������������������ TOKEN����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ACCESS_TOKEN����������� ������������������ =����������� ������������������ args[0].toString();����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //webBrowserPanel.setVisible(false);����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ System.out.println("Sdfsdfsdf");����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ upperFrame.setVisible(false);����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ upperFrame.dispose();����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ UIThread.setACCESS_TOKEN(ACCESS_TOKEN);����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ null;����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ });����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ }����������� ������������������
����������� ������������������
}����������� ������������������
결론적으로는����������� ������������������ 위에서����������� ������������������ JWebBrowser 라는����������� ������������������ 함수를����������� ������������������ 통해����������� ������������������ JPanel 안에����������� ������������������ DJNativeSwing-
SWT.jar����������� ������������������ 파일����������� ������������������ 안의����������� ������������������ 구현된����������� ������������������ 기능을����������� ������������������ 추가하여����������� ������������������ 브라우저처럼����������� ������������������ 사용할����������� ������������������ 수����������� ������������������ 있게����������� ������������������ 됩니다.����������� ������������������
Final Report
8
또한����������� ������������������ step1.jsp 에서는����������� ������������������ 웹에서����������� ������������������ 받은����������� ������������������ Access����������� ������������������ Token 을����������� ������������������ 자바스크립트로����������� ������������������ 실제����������� ������������������
J2SE 프로그램과����������� ������������������ 호출할����������� ������������������ 수����������� ������������������ 있게����������� ������������������ 됩니다.����������� ������������������ ����������� ������������������
����������� ������������������
(그림����������� ������������������ :����������� ������������������ 프로그램����������� ������������������ 위에����������� ������������������ 띄어진����������� ������������������ Native����������� ������������������ Browser)����������� ������������������
����������� ������������������
이렇게����������� ������������������ 가져온����������� ������������������ Access����������� ������������������ Token 은����������� ������������������ restFB(www.restfb.com)에서����������� ������������������ 제공하는����������� ������������������ JDK 용����������� ������������������
페이스북����������� ������������������ 라이브러리를����������� ������������������ 이용하여����������� ������������������ 유저����������� ������������������ 정보를����������� ������������������ 매칭시키게����������� ������������������ 됩니다.����������� ������������������ 이렇게����������� ������������������ 하여����������� ������������������
가져오게����������� ������������������ 되는����������� ������������������ 정보는����������� ������������������ 페이스북����������� ������������������ 사용자의����������� ������������������ 이름,이메일,생일����������� ������������������ 등의����������� ������������������ 정보와����������� ������������������ 친구����������� ������������������ 정보����������� ������������������
등을����������� ������������������ 가져올����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������
����������� ������������������ ����������� ������������������
Final Report
9
소스)����������� ������������������ 페이스북����������� ������������������ 매니저����������� ������������������ 소스����������� ������������������ 중����������� ������������������ 일부(FBManager.java)����������� ������������������
����������� ������������������ //����������� ������������������ 페이스북����������� ������������������ 연동에����������� ������������������ 필요한����������� ������������������ 토큰����������� ������������������ 및����������� ������������������ 객체����������� ������������������
����������� ������������������ private����������� ������������������ static����������� ������������������ String����������� ������������������ ACCESS_TOKEN����������� ������������������ ;����������� ������������������
����������� ������������������ static����������� ������������������ FacebookClient����������� ������������������ facebookClient;����������� ������������������
����������� ������������������
����������� ������������������ static����������� ������������������ FacebookClient����������� ������������������ publicOnlyFacebookClient;����������� ������������������
����������� ������������������ ����������� ������������������
����������� ������������������ public����������� ������������������ FBManager(String����������� ������������������ ACCESS_TOKEN){����������� ������������������
����������� ������������������ ����������� ������������������ this.ACCESS_TOKEN����������� ������������������ =����������� ������������������ ACCESS_TOKEN;����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ facebookClient����������� ������������������ =����������� ������������������ new����������� ������������������ DefaultFacebookClient(ACCESS_TOKEN);����������� ������������������
����������� ������������������ ����������� ������������������ publicOnlyFacebookClient����������� ������������������ =����������� ������������������ new����������� ������������������ DefaultFacebookClient();����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ }����������� ������������������
����������� ������������������ ����������� ������������������
����������� ������������������ public����������� ������������������ void����������� ������������������ postWall(String����������� ������������������ post)����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ FacebookType����������� ������������������ publishMessageResponse����������� ������������������ =����������� ������������������ null;����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ try����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ publishMessageResponse����������� ������������������ =����������� ������������������ facebookClient.publish("me/feed",����������� ������������������
FacebookType.class,����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ Parameter.with("message",����������� ������������������ post));����������� ������������������
����������� ������������������ ����������� ������������������ }����������� ������������������ catch(FacebookOAuthException����������� ������������������ e)����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ //error����������� ������������������ occur!!����������� ������������������
����������� ������������������ ����������� ������������������ }����������� ������������������
����������� ������������������ }����������� ������������������
위에서����������� ������������������ 처럼����������� ������������������ FBManager 라는����������� ������������������ 객체를����������� ������������������ 사용할����������� ������������������ 때에����������� ������������������ ACCESS_TOKEN 을����������� ������������������ 넣어����������� ������������������
사용하고,����������� ������������������ defaultfacebookClient����������� ������������������ 객체에����������� ������������������ 토큰값을����������� ������������������ 넘겨주어����������� ������������������ 실제로는����������� ������������������
postWall 함수와����������� ������������������ 같이(담벼락에����������� ������������������ 글을����������� ������������������ 남겨주는����������� ������������������ 함수)����������� ������������������ 쉽게����������� ������������������ 사용이����������� ������������������ 가능합니다.����������� ������������������ 이와����������� ������������������
같은����������� ������������������ 부분을����������� ������������������ 저희는����������� ������������������ 저희가����������� ������������������ 직접����������� ������������������ 만든����������� ������������������ 데이터����������� ������������������ 모델(UserEntry.java)에����������� ������������������ 매칭시켜서����������� ������������������
사용하였습니다.����������� ������������������
����������� ������������������ 실제로����������� ������������������ restFB 를����������� ������������������ 사용하면����������� ������������������ 위와����������� ������������������ 같이����������� ������������������ 저희����������� ������������������ 게임에서����������� ������������������ 남겨지는����������� ������������������ 메시지를����������� ������������������ 쉽게����������� ������������������
확인할����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������
����������� ������������������
����������� ������������������
����������� ������������������
Final Report
10
Echo����������� ������������������ Server����������� ������������������ and����������� ������������������ Packet����������� ������������������ Serialization����������� ������������������
실제����������� ������������������ 게임의����������� ������������������ 구성과����������� ������������������ DB 처리를����������� ������������������ 위해����������� ������������������ 저희는����������� ������������������ Echo����������� ������������������ Server 를����������� ������������������ 구축하였습니다.����������� ������������������ 이����������� ������������������ 서버는����������� ������������������
각����������� ������������������ 클라이언트마다����������� ������������������ Thread 를����������� ������������������ 열어두고����������� ������������������ 패킷을����������� ������������������ Serializable 을����������� ������������������ 통해����������� ������������������ 직렬화����������� ������������������ 하여����������� ������������������ 패킷����������� ������������������ 단위로����������� ������������������
수신하고����������� ������������������ 이를����������� ������������������ ServerMgr 을����������� ������������������ 통해����������� ������������������ 처리하게����������� ������������������ 됩니다.����������� ������������������
����������� ������������������
소스)����������� ������������������ 패킷의����������� ������������������ 구성(CPacket.java)����������� ������������������ 중����������� ������������������ 일부����������� ������������������
Final Report
11
public����������� ������������������ class����������� ������������������ CPacket����������� ������������������ implements����������� ������������������ Serializable{����������� ������������������
����������� ������������������ /**����������� ������������������
����������� ������������������ ����������� ������������������ *����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ */����������� ������������������
����������� ������������������ private����������� ������������������ static����������� ������������������ final����������� ������������������ long����������� ������������������ serialVersionUID����������� ������������������ =����������� ������������������ 4498887824473906148L;����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ ip;����������� ������������������ //����������� ������������������ User's����������� ������������������ IP����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ id;����������� ������������������ //����������� ������������������ User's����������� ������������������ ID����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ port;����������� ������������������ //����������� ������������������ User's����������� ������������������ Socket����������� ������������������ Port����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ no;����������� ������������������ //����������� ������������������ User's����������� ������������������ Number����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ token;����������� ������������������ //����������� ������������������ User's����������� ������������������ Facebook����������� ������������������ Token����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ task_type;����������� ������������������ //����������� ������������������ Packet's����������� ������������������ Task.����������� ������������������ [RECV����������� ������������������ /����������� ������������������ SEND]����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ task_title;����������� ������������������ //����������� ������������������ Task's����������� ������������������ name.����������� ������������������ [CHAT����������� ������������������ /����������� ������������������ WAIT����������� ������������������ /����������� ������������������ GAME]����������� ������������������
����������� ������������������ ����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ action;����������� ������������������ //����������� ������������������ TASK's����������� ������������������ Action����������� ������������������
����������� ������������������ private����������� ������������������ ����������� ������������������ String����������� ������������������ message;����������� ������������������ //����������� ������������������ ����������� ������������������ JSON����������� ������������������ ����������� ������������������ 으로����������� ������������������ 가지고����������� ������������������ 있다.����������� ������������������
����������� ������������������ ����������� ������������������
����������� ������������������ private����������� ������������������ ArrayList<String>����������� ������������������ omessage;����������� ������������������ //����������� ������������������ Object����������� ������������������
����������� ������������������ ����������� ������������������
����������� ������������������ private����������� ������������������ String����������� ������������������ getLocalServerIp()����������� ������������������
����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ try����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ for����������� ������������������ (Enumeration<NetworkInterface>����������� ������������������ en����������� ������������������ =����������� ������������������
NetworkInterface.getNetworkInterfaces();����������� ������������������ en.hasMoreElements();)����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ NetworkInterface����������� ������������������ intf����������� ������������������ =����������� ������������������ en.nextElement();����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ for����������� ������������������ (Enumeration<InetAddress>����������� ������������������ enumIpAddr����������� ������������������ =����������� ������������������ intf.getInetAddresses();����������� ������������������
enumIpAddr.hasMoreElements();)����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ InetAddress����������� ������������������ inetAddress����������� ������������������ =����������� ������������������ enumIpAddr.nextElement();����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ if����������� ������������������ (!inetAddress.isLoopbackAddress()����������� ������������������
&&����������� ������������������ !inetAddress.isLinkLocalAddress()����������� ������������������ &&����������� ������������������ inetAddress.isSiteLocalAddress())����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ inetAddress.getHostAddress().toString();����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ }����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ catch����������� ������������������ (SocketException����������� ������������������ ex)����������� ������������������ {}����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ null;����������� ������������������
����������� ������������������ }����������� ������������������
����������� ������������������ ����������� ������������������
����������� ������������������ public����������� ������������������ ����������� ������������������ CPacket()����������� ������������������ {����������� ������������������
����������� ������������������ ����������� ������������������ this.ip����������� ������������������ =����������� ������������������ getLocalServerIp();����������� ������������������
����������� ������������������ ����������� ������������������ this.id����������� ������������������ =����������� ������������������ "";����������� ������������������
Final Report
12
����������� ������������������ ����������� ������������������ this.port����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ ����������� ������������������ this.no����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ ����������� ������������������ this.token����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ ����������� ������������������ this.task_title����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ ����������� ������������������ this.task_type����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������
����������� ������������������ ����������� ������������������ this.action����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ ����������� ������������������ this.message����������� ������������������ =����������� ������������������ "";����������� ������������������
����������� ������������������ ����������� ������������������ omessage����������� ������������������ =����������� ������������������ new����������� ������������������ ArrayList<String>();����������� ������������������
����������� ������������������ }����������� ������������������
위와����������� ������������������ 같이����������� ������������������ Serializable 을����������� ������������������ implement 하여����������� ������������������ 구성하고����������� ������������������ 서버����������� ������������������ 또한����������� ������������������ 이와����������� ������������������ 같이����������� ������������������ 구성을����������� ������������������ 하여����������� ������������������
패킷을����������� ������������������ 직렬화����������� ������������������ 하였습니다.����������� ������������������
Final Report
13
����������� ������������������ (왼쪽����������� ������������������ :����������� ������������������ 서버의����������� ������������������ 구성,����������� ������������������ ����������� ������������������ 오른쪽����������� ������������������ :����������� ������������������ 클라이언트의����������� ������������������ 소켓����������� ������������������ 처리부분의����������� ������������������ 구성)����������� ������������������
서버의����������� ������������������ 구성은����������� ������������������ 위와����������� ������������������ 같습니다.����������� ������������������ ServerThread 는����������� ������������������ 결국����������� ������������������ 클라이언트의����������� ������������������ 스레드이며,����������� ������������������ 이는����������� ������������������
Thread 를����������� ������������������ 상속받고����������� ������������������ 있습니다.����������� ������������������ ServerMgr 는����������� ������������������ Main 함수를����������� ������������������ 가진����������� ������������������ 서버����������� ������������������ 프로그램의����������� ������������������ 메인입니다.����������� ������������������
이곳에서����������� ������������������ 클라이언트는����������� ������������������ ClientList 로����������� ������������������ 관리되고����������� ������������������ 각����������� ������������������ Thread 는����������� ������������������ 이곳에서����������� ������������������ 정의한����������� ������������������ 함수들에����������� ������������������
따라서����������� ������������������ 여러가지����������� ������������������ 행동을����������� ������������������ 하게����������� ������������������ 됩니다.����������� ������������������ 클라이언트����������� ������������������ 역시����������� ������������������ 비슷한����������� ������������������ 처리를����������� ������������������ 합니다.����������� ������������������
Final Report
14
����������� ������������������ 위와����������� ������������������ 같이����������� ������������������ 서버에서는����������� ������������������ 패킷을����������� ������������������ 송수신����������� ������������������ 받을����������� ������������������ 때에����������� ������������������ 패킷의����������� ������������������ 헤더����������� ������������������ 부분의����������� ������������������ 메시지를����������� ������������������ 보고����������� ������������������
서버객체의����������� ������������������ 함수를����������� ������������������ 호출하게����������� ������������������ 됩니다.����������� ������������������
Final Report
15
����������� ������������������ 클라이언트����������� ������������������ 역시����������� ������������������ 서버에서����������� ������������������ 보내준����������� ������������������ 메시지를����������� ������������������ 토대로����������� ������������������ 메시지����������� ������������������ 분기처리를����������� ������������������ 하여����������� ������������������ 클라이언트의����������� ������������������
여러����������� ������������������ 액션들을����������� ������������������ 처리하게����������� ������������������ 됩니다.����������� ������������������
실제로����������� ������������������ CPacket 클래스����������� ������������������ 이외에����������� ������������������ 보내줄����������� ������������������ 클래스는����������� ������������������ Jackson����������� ������������������ JSON 라이브러리를����������� ������������������ 통해����������� ������������������
JSON 으로����������� ������������������ 변경한����������� ������������������ 뒤����������� ������������������ 실제����������� ������������������ CPacket 의����������� ������������������ Message����������� ������������������ 변수에����������� ������������������ 넣어서����������� ������������������ String 으로����������� ������������������ 송수신을����������� ������������������
처리하게����������� ������������������ 됩니다.����������� ������������������ 이에����������� ������������������ 따라����������� ������������������ 저희의����������� ������������������ 각����������� ������������������ Entry 들은����������� ������������������ getJSON()����������� ������������������ /����������� ������������������ setJSON()을����������� ������������������ 가지고����������� ������������������ 있습니다.����������� ������������������
Database����������� ������������������
저희는����������� ������������������ 유저의����������� ������������������ 스코어����������� ������������������ 정보를����������� ������������������ 기록하기����������� ������������������ 위하여����������� ������������������ DB 매니저를����������� ������������������ 구축하였습니다.����������� ������������������ 실제로����������� ������������������
DB 는����������� ������������������ 서버의����������� ������������������ 클라이언트����������� ������������������ 스레드����������� ������������������ 단위로����������� ������������������ 연결을����������� ������������������ 하게����������� ������������������ 되고����������� ������������������ 저희는����������� ������������������ 직접����������� ������������������ 구현한����������� ������������������ 풀����������� ������������������ 메니저����������� ������������������
방식을����������� ������������������ 통해����������� ������������������ DB 연결시����������� ������������������ Pool 을����������� ������������������ 잡고����������� ������������������ 스래드����������� ������������������ 단위로����������� ������������������ Pool 을����������� ������������������ 할당해����������� ������������������ 주는����������� ������������������ 방식으로����������� ������������������ Max����������� ������������������
Connection 문제를����������� ������������������ 해결하였습니다.����������� ������������������
Final Report
16
����������� ������������������ 위는����������� ������������������ 전체적인����������� ������������������ DB����������� ������������������ 매니저의����������� ������������������ 구성입니다.����������� ������������������ 여러����������� ������������������ Query 를����������� ������������������ 처리하는����������� ������������������ 함수와����������� ������������������ Database 라는����������� ������������������
db 객체를����������� ������������������ 통해����������� ������������������ 여러����������� ������������������ 사용자와����������� ������������������ 관련된����������� ������������������ 행동을����������� ������������������ 하게����������� ������������������ 됩니다.����������� ������������������
����������� ������������������ 위����������� ������������������ 부분은����������� ������������������ 저희����������� ������������������ PoolManager 의����������� ������������������ 소스입니다.����������� ������������������ PoolManager 는����������� ������������������ 싱글톤����������� ������������������ 패턴으로����������� ������������������
Final Report
17
JDBC 드라이버로����������� ������������������ Mysql 과����������� ������������������ 커넥션을����������� ������������������ 맺고����������� ������������������ 일정����������� ������������������ 량의����������� ������������������ Pool 을����������� ������������������ 가지고����������� ������������������ 전반적인����������� ������������������ DB 에����������� ������������������ 대한����������� ������������������
처리를����������� ������������������ 하게����������� ������������������ 됩니다.����������� ������������������
����������� ������������������ 위는����������� ������������������ 현재����������� ������������������ 구성되어����������� ������������������ 있는����������� ������������������ Schema 입니다.����������� ������������������ no 를����������� ������������������ PK 로����������� ������������������ 두고����������� ������������������ 처리를����������� ������������������ 하게����������� ������������������ 됩니다.����������� ������������������
Swing����������� ������������������ Library����������� ������������������
����������� ������������������
RoomFrame 부분에����������� ������������������ 게임을����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있는����������� ������������������ 보드판을����������� ������������������ 이중 Array����������� ������������������ List 로����������� ������������������ 구현하고,����������� ������������������
CirclePanel 에����������� ������������������ 돌의����������� ������������������ 위치를����������� ������������������ Array����������� ������������������ List 로����������� ������������������ 좌표화����������� ������������������ 하여,����������� ������������������ 마우스����������� ������������������ 클릭하는����������� ������������������ 위치에����������� ������������������ 따라서����������� ������������������
함수를����������� ������������������ 통해����������� ������������������ 돌의����������� ������������������ 움직임을����������� ������������������ 제어합니다.����������� ������������������ 옮기고����������� ������������������ 싶은����������� ������������������ 자신의����������� ������������������ 돌을����������� ������������������ 클릭하면����������� ������������������ 돌의����������� ������������������ 테두리����������� ������������������ 색이����������� ������������������
Final Report
18
파란색으로����������� ������������������ 바뀌며,����������� ������������������ 갈����������� ������������������ 수����������� ������������������ 있는����������� ������������������ 방향의����������� ������������������ 테두리가����������� ������������������ 파란색으로����������� ������������������ 바뀝니다.����������� ������������������ 옮길����������� ������������������ 수����������� ������������������ 있는����������� ������������������ 돌은����������� ������������������
최대 2 개이며����������� ������������������ 테두리가����������� ������������������ 파란색����������� ������������������ 인����������� ������������������ 칸을����������� ������������������ 택하게����������� ������������������ 되면����������� ������������������ 돌들이����������� ������������������ 옮겨집니다.����������� ������������������
����������� ������������������ 위는����������� ������������������ 실제����������� ������������������ 핵심����������� ������������������ 로직����������� ������������������ 부분입니다.����������� ������������������ 돌이����������� ������������������ 이동할����������� ������������������ 수����������� ������������������ 있는지에����������� ������������������ 대한����������� ������������������ 여부와����������� ������������������ 색깔을����������� ������������������ 입혀주는����������� ������������������
등의����������� ������������������ 기능을����������� ������������������ CirclePanel����������� ������������������ 내에서����������� ������������������ 구현하게����������� ������������������ 됩니다.����������� ������������������
Final Report
19
����������� ������������������ 위는����������� ������������������ StoneEntry.java����������� ������������������ 즉����������� ������������������ 한����������� ������������������ 개의����������� ������������������ 돌����������� ������������������ 객체의����������� ������������������ 속성정보입니다.����������� ������������������ 이러한����������� ������������������ 객체를����������� ������������������ 통해����������� ������������������
CirclePanel 에서는����������� ������������������ 아래와����������� ������������������ 같은����������� ������������������ 로직으로����������� ������������������ repaint()함수를����������� ������������������ 발생시켜����������� ������������������ Override 한����������� ������������������
paint 함수에서����������� ������������������ 돌����������� ������������������ 전환을����������� ������������������ 처리합니다.����������� ������������������
����������� ������������������
Final Report
20
Epilogue����������� ������������������
강수현����������� ������������������ :����������� ������������������ 자바����������� ������������������ 수업시간에����������� ������������������ 배우지����������� ������������������ 않은����������� ������������������ 세세한����������� ������������������ 내용들을����������� ������������������ 팀플을����������� ������������������ 하면서����������� ������������������ 많이����������� ������������������ 배웠다.����������� ������������������
textpad 말고����������� ������������������ 다른����������� ������������������ 개발툴을����������� ������������������ 사용하는����������� ������������������ 법도����������� ������������������ 배우면서����������� ������������������ 자바프로그래밍이����������� ������������������ 한결����������� ������������������ 쉽게����������� ������������������ 느껴졌다.����������� ������������������
지금까지했던����������� ������������������ 과제중에����������� ������������������ 가장����������� ������������������ 복잡하고����������� ������������������ 많은����������� ������������������ 내용들을����������� ������������������ 필요로한만큼����������� ������������������ 어려움도����������� ������������������ 많앗지만����������� ������������������
그만큼의����������� ������������������ 성과를����������� ������������������ 얻어낸것����������� ������������������ 같아서����������� ������������������ 뿌듯하다.����������� ������������������
����������� ������������������
김성진����������� ������������������ :����������� ������������������ 팀장����������� ������������������ 역할을����������� ������������������ 맡아서����������� ������������������ 팀원간����������� ������������������ 분업의����������� ������������������ 필요성을����������� ������������������ 알게����������� ������������������ 되었고,����������� ������������������ 여러����������� ������������������ 가지����������� ������������������ 개발����������� ������������������ 도구����������� ������������������
등을����������� ������������������ 알게����������� ������������������ 되었다.����������� ������������������ 수업시간에����������� ������������������ 배운����������� ������������������ class 의����������� ������������������ 개념이나����������� ������������������ 종속개념을����������� ������������������ 실제로����������� ������������������ 작업을����������� ������������������ 하면서����������� ������������������
조금이나마����������� ������������������ 더����������� ������������������ 이해����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있었고,����������� ������������������ 가능하면����������� ������������������ 함수를����������� ������������������ 이용하면����������� ������������������ 좀더����������� ������������������ 좋은����������� ������������������ 프로그램을����������� ������������������ 만들����������� ������������������ 수����������� ������������������
있음을����������� ������������������ 새삼����������� ������������������ 느낄����������� ������������������ 수����������� ������������������ 있었다.����������� ������������������ 그리고����������� ������������������ 작업에����������� ������������������ 필요한����������� ������������������ IDE(����������� ������������������ Netbean,����������� ������������������ Eclipse)과����������� ������������������ Svn 이라는����������� ������������������
개발����������� ������������������ 도구도����������� ������������������ 새롭게����������� ������������������ 알����������� ������������������ 수����������� ������������������ 있었다.����������� ������������������ ����������� ������������������
����������� ������������������
서왕덕����������� ������������������ :����������� ������������������ 수업시간에����������� ������������������ 배운것����������� ������������������ 말고도����������� ������������������ 많은����������� ������������������ 것을����������� ������������������ 배울����������� ������������������ 수있었던����������� ������������������ 좋은����������� ������������������ 시간이었다.����������� ������������������ 자바����������� ������������������
프로그램을����������� ������������������ 만드는데����������� ������������������ textpad����������� ������������������ 말고����������� ������������������ eclipse����������� ������������������ 를����������� ������������������ 배워서����������� ������������������ 써서����������� ������������������ 앞으로����������� ������������������ 좀더����������� ������������������ 다양한����������� ������������������ 프로그램을����������� ������������������
만들수����������� ������������������ 있을거같다.����������� ������������������
����������� ������������������
장익환����������� ������������������ :����������� ������������������ 이번����������� ������������������ 프로젝트에서����������� ������������������ 나는����������� ������������������ 5 년간����������� ������������������ 휴학생활을����������� ������������������ 하며����������� ������������������ 후배들에게����������� ������������������ 도움을����������� ������������������ 주었던����������� ������������������ 자바����������� ������������������
프로젝트에����������� ������������������ 대해����������� ������������������ 실제로����������� ������������������ 참여하게����������� ������������������ 되어����������� ������������������ 매우����������� ������������������ 감회가����������� ������������������ 새로웠다.����������� ������������������ 이에����������� ������������������ 최초에����������� ������������������ 욕심이����������� ������������������ 앞서����������� ������������������ 그간����������� ������������������
내가����������� ������������������ 실무에서����������� ������������������ 익히며����������� ������������������ 언젠가는����������� ������������������ 한번쯤����������� ������������������ 혼합해서����������� ������������������ 만들어야����������� ������������������ 겠다는����������� ������������������ 기술들,����������� ������������������ 즉����������� ������������������ 소켓통신과����������� ������������������
에코서버,����������� ������������������ C/S 간의����������� ������������������ 데이터����������� ������������������ 직렬화,����������� ������������������ 소셜����������� ������������������ 플러그인����������� ������������������ 연동����������� ������������������ 등의����������� ������������������ 기술을����������� ������������������ 도입시켜보기로����������� ������������������ 하였다.����������� ������������������
마침����������� ������������������ 팀원들도����������� ������������������ 모두����������� ������������������ 게임을����������� ������������������ 만드는����������� ������������������ 것을����������� ������������������ 원했고,����������� ������������������ 이에����������� ������������������ 서버는����������� ������������������ 개인적으로����������� ������������������ 만들어����������� ������������������ 놓은����������� ������������������ 소켓����������� ������������������
스래드����������� ������������������ 서버를����������� ������������������ 응용하고����������� ������������������ 객체를����������� ������������������ 만들고����������� ������������������ 게임을����������� ������������������ 구상하였다.����������� ������������������ 조원들에게����������� ������������������ 부탁한����������� ������������������ 설계나����������� ������������������ 게임에����������� ������������������
대한����������� ������������������ 이해는����������� ������������������ 훌륭하였고����������� ������������������ 나����������� ������������������ 역시����������� ������������������ 구현을����������� ������������������ 하는데����������� ������������������ 있어����������� ������������������ 부족한����������� ������������������ 점이����������� ������������������ 없다����������� ������������������ 생각하여����������� ������������������ 최초에는����������� ������������������
LWJGL 등의����������� ������������������ 자바����������� ������������������ 게임엔진을����������� ������������������ 도입하여����������� ������������������ 테스트����������� ������������������ 하는����������� ������������������ 등의����������� ������������������ 열의를����������� ������������������ 보였지만����������� ������������������ 시간이����������� ������������������ 지나고����������� ������������������
40 시간����������� ������������������ 이상을����������� ������������������ 자바����������� ������������������ 팀����������� ������������������ 프로젝트를����������� ������������������ 위한����������� ������������������ 코딩만����������� ������������������ 하고����������� ������������������ 있는����������� ������������������ 나와����������� ������������������ 우리����������� ������������������ 조����������� ������������������ 사람들을����������� ������������������ 보며����������� ������������������ 너무����������� ������������������
과도한����������� ������������������ 욕심을����������� ������������������ 버린����������� ������������������ 것이����������� ������������������ 아닌가����������� ������������������ 라는����������� ������������������ 생각이����������� ������������������ 들었다.����������� ������������������ 결론적으로����������� ������������������ 게임����������� ������������������ core 부분보다����������� ������������������ 소셜����������� ������������������
연동이나����������� ������������������ 게임����������� ������������������ 서버,����������� ������������������ 채팅����������� ������������������ 등에����������� ������������������ 시간을����������� ������������������ 너무����������� ������������������ 많이����������� ������������������ 빼앗긴����������� ������������������ 것����������� ������������������ 같아서����������� ������������������ 이����������� ������������������ 부분이����������� ������������������ 상당히����������� ������������������ 아쉬운����������� ������������������
점으로����������� ������������������ 남는다.����������� ������������������ 하지만����������� ������������������ 후배들에게����������� ������������������ 자바에����������� ������������������ 대한����������� ������������������ 전반적인����������� ������������������ OOP 적인����������� ������������������ 컴퓨터����������� ������������������ 프로그램����������� ������������������ 설계����������� ������������������
방법에����������� ������������������ 대한����������� ������������������ 접근,����������� ������������������ 예를들어����������� ������������������ Swing 라이브러리를����������� ������������������ 상속받은����������� ������������������ 사용자����������� ������������������ 정의����������� ������������������ 커스톰����������� ������������������ 클래스����������� ������������������ 라던가,����������� ������������������
혹은����������� ������������������ 수업시간에����������� ������������������ 배우지����������� ������������������ 못한����������� ������������������ ArrayList 나����������� ������������������ 해시맵����������� ������������������ 등의����������� ������������������ 자료형����������� ������������������ 등에����������� ������������������ 대해����������� ������������������ 함께����������� ������������������ 공부할����������� ������������������ 수����������� ������������������
있는����������� ������������������ 기회가����������� ������������������ 되어����������� ������������������ 좋은����������� ������������������ 시간을����������� ������������������ 가지게����������� ������������������ 된����������� ������������������ 것����������� ������������������ 같다.����������� ������������������ 이러한����������� ������������������ 일생에����������� ������������������ 남을����������� ������������������ 만한����������� ������������������ 기억을����������� ������������������ 가지게����������� ������������������
해준����������� ������������������ 교수님께����������� ������������������ 감사를����������� ������������������ 드리며,����������� ������������������ 근����������� ������������������ 한달을����������� ������������������ 주경야독으로����������� ������������������ 프로젝트에����������� ������������������ 매진해����������� ������������������ 온����������� ������������������ 후배����������� ������������������
조원들에게도����������� ������������������ 그들의����������� ������������������ 열정에����������� ������������������ 경의를����������� ������������������ 표한다.����������� ������������������
황정윤����������� ������������������ :����������� ������������������ 자바����������� ������������������ 팀플을����������� ������������������ 하면서,����������� ������������������ 수업시간에����������� ������������������ 배우지����������� ������������������ 않았던����������� ������������������ 다양한����������� ������������������ IDE����������� ������������������ 프로그램을����������� ������������������ 사용할����������� ������������������
수����������� ������������������ 있어서����������� ������������������ 흥미롭고����������� ������������������ 유익했던����������� ������������������ 시간이었다.����������� ������������������ UI 작업을����������� ������������������ 하면서,����������� ������������������ 신기했고����������� ������������������ 여러개의����������� ������������������ 생성자와����������� ������������������
클래스를����������� ������������������ 사용하는����������� ������������������ 코드를����������� ������������������ 다루는����������� ������������������ 건����������� ������������������ 처음이라����������� ������������������ 복잡했지만����������� ������������������ 더����������� ������������������ 많이����������� ������������������ 배운����������� ������������������ 기분이다.����������� ������������������ 자바에����������� ������������������
흥미를����������� ������������������ 느끼고����������� ������������������ 더����������� ������������������ 배우는����������� ������������������ 계기가����������� ������������������ 될����������� ������������������ 것����������� ������������������ 같다����������� ������������������