LAMPIRAN A
A- 1 -
using UnityEngine;
using System.Collections;
public class AI : MonoBehaviour {
#region var
private string[] strRandSpawn5 = new string[5]; private int intCurSpawn5 = 0;
public struct Node {
public string strNodeId;
public string strNodeIdParent; public string strNodeIdChild; public int intHighNum;
public int intSpaceLeft; public int intSpawnPos; public string OwnBoard; public string strDirection; public bool isIdle;
}
public Node[] myNode = new Node[1364]; public string strSaveDataAIArah = ""; public string strSaveDataAISpawn = "";
public controller_Gameplay myController_Gameplay; public Module myModule;
#endregion
public void setNodeID() {
int intCurArah = 1; int intIdxParent = -1;
for (int i = 0; i < myNode.Length; i++) {
if (i < 4) {
myNode[i].strNodeIdParent = "";
myNode[i].strNodeId = intCurArah.ToString() + "0000";
if (i < 20) myNode[i].strNodeId =
myNode[i].strNodeIdParent.Substring(0, 1) + intCurArah.ToString() + "000"; // 16 + 4
else if (i < 84) myNode[i].strNodeId =
LAMPIRAN A
A- 2 -
else if (i < 340) myNode[i].strNodeId =
myNode[i].strNodeIdParent.Substring(0, 3) + intCurArah.ToString() + "0"; // 256 + 64 + 16 + 4
else if (i < 1364) myNode[i].strNodeId =
myNode[i].strNodeIdParent.Substring(0, 4) + intCurArah.ToString(); // 1024 + 256 + 64 + 16 + 4
}
setNodeStrDirection(i, intCurArah); intCurArah++;
if (intCurArah > 4) {
void setNodeStrDirection(int idx, int dir) {
switch (dir) {
case 1: myNode[idx].strDirection = "Up"; break;
case 2: myNode[idx].strDirection = "Down"; break;
case 3: myNode[idx].strDirection = "Left"; break;
case 4: myNode[idx].strDirection = "Right"; break;
} }
public void resetNode() {
for (int i = 0; i < myNode.Length; i++) {
myNode[i].intHighNum = 0; myNode[i].intSpaceLeft = 0; myNode[i].intSpawnPos = -1; myNode[i].OwnBoard = ""; myNode[i].isIdle = false; }
strSaveDataAIArah = ""; strSaveDataAISpawn = "";
for (int j = 0; j < strRandSpawn5.Length; j++) strRandSpawn5[j] =
myModule.RandomItemInString("0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"); ContinueAI();
}
void simulator4(int idxMyNode) {
bool bAdd = false;
//declare the iBoard as template for move test int[][] iBoard;
LAMPIRAN A rd, idxString), out iBoard[e][d]);
idxString++; }
} }
else if (idxMyNode >= 4) {
idxString = 1;
//find the parent Node
int idxParentGet = findIdxParent(idxMyNode); for (int a = 0; a < myNode.Length; a++)
{
if (myNode[a].strNodeId == myNode[idxMyNode].strNodeIdParent)
{
idxParentGet = a; break;
} }
//pass the parent's OwnBoard to iBoard for (int b = 0; b < 4; b++)
{
for (int c = 0; c < 4; c++) {
int.TryParse(myModule.GetItemPos(myNode[idxParentGet].OwnBoard, idxString), out iBoard[c][b]);
idxString++; }
} }
int idxPick = 1;
int intNextSpawn = -1; bool bolSpawn = false;
//find appropriate spot to spawn next Number from strRandSpawn5
while (!bolSpawn && idxPick <=
LAMPIRAN A
A- 4 -
int.TryParse(myModule.GetItemPos(strRandSpawn5[intCurSpawn5], idxPick), out intNextSpawn);
////print("callout : " + intNextSpawn.ToString()); int kolSpawn = intNextSpawn % 4;
int brsSpawn = intNextSpawn / 4; if (iBoard[kolSpawn][brsSpawn] == 0) {
iBoard[kolSpawn][brsSpawn] = 2; bolSpawn = true;
}
LAMPIRAN A
// save spawnPos....ownBoard...highestPoint.... spaceLeft...
// convert back to string string strBoardResult = ""; int inthighNum = 0;
int intFreeSpots = 0;
for (int m = 0; m < 4; m++)
if (iBoard[n][m] > inthighNum) inthighNum = iBoard[n][m];
if (iBoard[n][m] == 0) intFreeSpots += 1; }
}
myNode[idxMyNode].intSpawnPos = intNextSpawn; myNode[idxMyNode].OwnBoard = strBoardResult; myNode[idxMyNode].intHighNum = inthighNum; myNode[idxMyNode].intSpaceLeft = intFreeSpots; if (!bAdd) myNode[idxMyNode].isIdle = true; else
{
if (idxMyNode < 4) myNode[idxMyNode].isIdle = false;
LAMPIRAN A
//get bottom best value int getTmpIdx = 340; int intHighNum = 0; int intSpaceLeft = 0;
for (int v = 340; v < myNode.Length; v++) {
if (!myNode[v].isIdle && ((intHighNum <
myNode[v].intHighNum) || (intHighNum == myNode[v].intHighNum && intSpaceLeft < myNode[v].intSpaceLeft)))
{
getTmpIdx = v;
intHighNum = myNode[v].intHighNum; intSpaceLeft = myNode[v].intSpaceLeft; }
if (myNode[x].strNodeId == myNode[getTmpIdx].strNodeIdParent)
myController_Gameplay.intUpdate = 10; }
int findIdxParent(int idxChild) {
int idxParentGet = -1;
for (int a = 0; a < myNode.Length; a++) {
if (myNode[a].strNodeId == myNode[idxChild].strNodeIdParent)
{
idxParentGet = a; break;
} }
LAMPIRAN A
A- 9 -
LAMPIRAN B
B- 1 -
using UnityEngine;
using System.Collections; [System.Serializable] public class Box2048 {
public int intIdx; public int intKol; public int intBrs; public float posX; public float posY; public int FillNum; }
[System.Serializable] public class Number2048 {
public int intIdx; public int intKol; public int intBrs; public float posX; public float posY; public int Number; public GameObject GO; }
public class controller_Gameplay : MonoBehaviour {
#region var
public int intUpdate = -1; public bool isInput = false; public int intWaitMove;
public bool bolAllMove = false;
public Box2048[] myBox = new Box2048[16];
public Number2048[] myNumber = new Number2048[16]; public bool[] isNumberMove = new bool[16];
private int intCountMove = -1; private int intCurSpawn = -1; private string strCurMove = ""; public AI myAI;
public string strMasterBoard = ""; public Module myModule;
#endregion
// Use this for initialization void Start () {
//print("void start");
for (int i = 0; i < myBox.Length; i++) {
myBox[i].intIdx = i;
myBox[i].intKol = (i % 4); myBox[i].intBrs = (i / 4);
LAMPIRAN B
B- 2 -
myBox[i].FillNum = 0; myNumber[i].intIdx = i;
myNumber[i].intKol = (i % 4); myNumber[i].intBrs = (i / 4);
myNumber[i].posX = -4.0f + (2.0f * (i % 4)); myNumber[i].posY = 3.0f - (2.0f * (i / 4)); myNumber[i].Number = 0;
}
myAI.setNodeID(); intUpdate = 5; }
// Update is called once per frame void Update() intCountMove = 0; intUpdate = 15; break;
case 15: intUpdate = 0; intCountMove++;
if (intCountMove > 5) intUpdate = 5; else GUI.Box(new Rect(0, 0, Screen.width, Screen.height), "The game ends /n the time is "+ Time.time);
break;
case 500 : if (Input.GetKeyDown(KeyCode.Space)) {
LAMPIRAN B
//convert currentBoard to string strMasterBoard = "";
for (int i = 0; i < myNumber.Length; i++) strMasterBoard = myModule.AddItem(strMasterBoard, myNumber[i].Number.ToString());
//call AI to start myAI.resetNode(); }
void spawnNumber(int intPosSpawn) {
//print("void spawnNumber"); myBox[intPosSpawn].FillNum = 2; myNumber[intPosSpawn].Number = 2; myNumber[intPosSpawn].GO =
Instantiate(Resources.Load("Numbers/GO_2")) as GameObject; myNumber[intPosSpawn].GO.transform.position = new
Vector3(myNumber[intPosSpawn].posX, myNumber[intPosSpawn].posY, 0.0f); intUpdate = 25;
}
public void moveNumber(string direction) {
//print("void moveNumber");
//set EndPos (order based on direction) //#######################################// #region RIGHT
if (direction == "Right") { k].GO.GetComponent<controller_moveAnimTes>().endPos = new
Vector3(myNumber[(4 * j) + i].posX, myNumber[(4 * j) + k].posY, 0.0f); myNumber[(4 * j) +
k].GO.GetComponent<controller_moveAnimTes>().interval =
LAMPIRAN B k].GO.GetComponent<controller_moveAnimTes>().endPos = new
Vector3(myNumber[(4 * j) + i].posX, myNumber[(4 * j) + k].posY, 0.0f); myNumber[(4 * j) +
k].GO.GetComponent<controller_moveAnimTes>().interval =
Mathf.Abs(myBox[(4 * j) + k].intKol - myBox[(4 * j) + i].intKol);
isNumberMove[(4 * j) + k] =
if (direction == "Left") {
if (myBox[(4*j)+k].FillNum == 0) { k].GO.GetComponent<controller_moveAnimTes>().endPos = new
LAMPIRAN B
B- 5 -
myNumber[(4 * j) + k].GO.GetComponent<controller_moveAnimTes>().interval =
Mathf.Abs(myBox[(4 * j) + k].intKol - myBox[(4 * j) + i].intKol);
isNumberMove[(4 * j) + k] = true; myBox[(4 * j) + i].FillNum *= 2; myBox[(4*j)+k].FillNum = 0; break; k].GO.GetComponent<controller_moveAnimTes>().endPos = new
Vector3(myNumber[(4 * j) + i].posX, myNumber[(4 * j) + k].posY, 0.0f); myNumber[(4 * j) +
k].GO.GetComponent<controller_moveAnimTes>().interval =
Mathf.Abs(myBox[(4 * j) + k].intKol - myBox[(4 * j) + i].intKol);
isNumberMove[(4 * j) + k] =
if (direction == "Down") { //kosong jd tidak ad yg perlu digeser
{
continue; }
LAMPIRAN B
B- 6 -
{
myNumber[(4 * k) + i].GO.GetComponent<controller_moveAnimTes>().endPos = new
Vector3(myNumber[(4 * k) + i].posX, myNumber[(4 * j) + i].posY, 0.0f); myNumber[(4 * k) +
i].GO.GetComponent<controller_moveAnimTes>().interval =
Mathf.Abs(myBox[(4 * k) + i].intBrs - myBox[(4 * j) + i].intBrs);
isNumberMove[(4 * k) + i] = true; nilai.... asal jd nol krn digeser
{
myNumber[(4 * k) + i].GO.GetComponent<controller_moveAnimTes>().endPos = new
Vector3(myNumber[(4 * k) + i].posX, myNumber[(4 * j) + i].posY, 0.0f); myNumber[(4 * k) +
i].GO.GetComponent<controller_moveAnimTes>().interval =
Mathf.Abs(myBox[(4 * k) + i].intBrs - myBox[(4 * j) + i].intBrs);
isNumberMove[(4 * k) + i] = i].FillNum != 0)//tdk bisa geser krn nilai beda
{
if (direction == "Up") { //kosong jd tidak ad yg perlu digeser
LAMPIRAN B
B- 7 -
continue; }
else if (myBox[(4 * k) + i].FillNum == myBox[(4 * j) + i].FillNum) //timpa... nilai sama.... jd tujuan x2... asal jd nol krn digeser
{
myNumber[(4 * k) + i].GO.GetComponent<controller_moveAnimTes>().endPos = new
Vector3(myNumber[(4 * k) + i].posX, myNumber[(4 * j) + i].posY, 0.0f); myNumber[(4 * k) +
i].GO.GetComponent<controller_moveAnimTes>().interval =
Mathf.Abs(myBox[(4 * k) + i].intBrs - myBox[(4 * j) + i].intBrs);
isNumberMove[(4 * k) + i] = true; nilai.... asal jd nol krn digeser
{
myNumber[(4 * k) + i].GO.GetComponent<controller_moveAnimTes>().endPos = new
Vector3(myNumber[(4 * k) + i].posX, myNumber[(4 * j) + i].posY, 0.0f); myNumber[(4 * k) +
i].GO.GetComponent<controller_moveAnimTes>().interval =
Mathf.Abs(myBox[(4 * k) + i].intBrs - myBox[(4 * j) + i].intBrs);
isNumberMove[(4 * k) + i] = i].FillNum != 0)//tdk bisa geser krn nilai beda
{
intWaitMove = 0;
bool isSthMove = false;
for (int k = 0; k < myNumber.Length; k++) {
if (isNumberMove[k]) {
LAMPIRAN B
B- 8 -
myNumber[k].GO.GetComponent<controller_moveAnimTes>().startPos = new Vector3(myNumber[k].posX, myNumber[k].posY, 0.0f);
myNumber[k].GO.GetComponent<controller_moveAnimTes>().startTime =
isSthMove = true; }
}
if (isSthMove) bolAllMove = true; else decreaseIntWaitMove();
}
public void decreaseIntWaitMove() {
//print("void decreaseIntWaitMove..."); intWaitMove--;
//print("hasil pengurangan..." + intWaitMove.ToString()); if (intWaitMove <= 0)
{
bolAllMove = false; afterMove();
if (myNumber[i].Number > 0) {
myNumber[i].GO.transform.position = new Vector3(myNumber[i].posX, myNumber[i].posY, 0.0f);
GameObject.Destroy(myNumber[i].GO.gameObject); }
myNumber[i].Number = myBox[i].FillNum; if (myNumber[i].Number > 0)
{
myNumber[i].GO = Instantiate(Resources.Load("Numbers/GO_" + myNumber[i].Number.ToString())) as GameObject;
myNumber[i].GO.transform.position = new Vector3(myNumber[i].posX, myNumber[i].posY, 0.0f);
LAMPIRAN B
B- 9 -
if (myNumber[i].Number == 2048) {
GameObject.Find("EventSystem").SendMessage("Finish"); }
if (myNumber[i].Number == 1024) {
GameObject.Find("EventSystem").SendMessage("Catat"); }
isNumberMove[i] = false; }
//can Spawn ???
bool canSpawn = false;
for (int j = 0; j < myBox.Length; j++) {
if (myBox[j].FillNum == 0) {
canSpawn = true; break;
} }
//print("void afterMove => cek Can Spawn???"); if (canSpawn) bool isPlayable = false;
for (int j = 0; j < myNumber.Length; j++) {
//not mostLeft if (j % 4 != 0) {
if (myNumber[j].Number == myNumber[j - 1].Number) {
isPlayable = true; break;
if (myNumber[j].Number == myNumber[j + 1].Number) {
isPlayable = true; break;
} }
//not mostTop
LAMPIRAN B
B- 10 -
{
if (myNumber[j].Number == myNumber[j - 4].Number) {
isPlayable = true; break;
} }
//not mostBottom else if (j / 4 != 3) {
if (myNumber[j].Number == myNumber[j + 4].Number) {
isPlayable = true; break;
} }
}
if (isPlayable) intUpdate = 10; else intUpdate = 40;
LAMPIRAN C
C-- 1 --
using UnityEngine;
using System.Collections;
public class controller_moveAnimTes : MonoBehaviour { //tes
public GameObject myGO_AnimTes;
public controller_Gameplay myGameplayScript; public Vector3 startPos;
public Vector3 endPos; public Vector4 startColor; public Vector4 endColor; public float speed = 1.0f; public float interval = 1.0f; public float startTime;
public float journeyLength; private float colorLength; public bool isMoveable;
// Use this for initialization void Start () {
startTime = Time.time;
journeyLength = Vector3.Distance(startPos, endPos); //startColor = new
Vector4(this.gameObject.GetComponent<SpriteRenderer>().color.r, //colorLength = Vector4.Distance(startColor, endColor); //---//
}
// Update is called once per frame void Update()
{
if (isMoveable && myGameplayScript.bolAllMove) {
//print("initial calculate ");
float distCovered = (Time.time - startTime) * speed * interval;
float fracJourney = distCovered / journeyLength; //print("about to transform");
myGO_AnimTes.transform.position = Vector3.Lerp(startPos, endPos, fracJourney);
//print("transform is done ");
LAMPIRAN C
C-- 2 --
isMoveable = false;
myGameplayScript.decreaseIntWaitMove(); }
//float fadeCovered = (Time.time - startTime) * speed; //float fracFading = fadeCovered / colorLength;
//myGO_AnimTes.GetComponent<SpriteRenderer>().color = Vector4.Lerp(startColor, endColor, fracFading);
} }
LAMPIRAN C
C-3-
using UnityEngine;
using System.Collections;
public class Module : MonoBehaviour {
public string AddItem(string sourceString, string addString) {
string temp = sourceString; if (temp == "")
{
temp += addString; }
public string AddItemReversed(string sourceString, string addString)
{
string temp = sourceString; if (temp == "")
{
temp += addString; }
public string RandomItemInString(string pstr) {
int roundDirection; string temp1 = pstr; string temp2 = "";
int maxItem = GetItemCount(pstr); int maxRound = Random.Range(5, 10); int front = 1;
LAMPIRAN C
C-4-
if (roundDirection == 1) {
temp2 += GetItemPos(temp1, front); front += 1;
} else {
temp2 += GetItemPos(temp1, last); last -= 1;
public int GetItemCount(string pstr) {
int temp = 1;
if (pstr == "") return temp; int maxChar = pstr.Length;
for (int i = 0; i < maxChar; i++) {
if (pstr.Substring(i, 1) == ",") {
public string GetItemPos(string pstr, int pos) {
string temp = ""; int count = 1;
int maxChar = pstr.Length;
for (int i = 0; i < maxChar; i++) {
if (pstr.Substring(i, 1) == ",") {
LAMPIRAN C
C-5-
} }
if ((count + 1) < pos) temp = ""; return temp;
LAMPIRAN D
D-1-
using UnityEngine;
using System.Collections;
public class Module : MonoBehaviour {
public string AddItem(string sourceString, string addString) {
string temp = sourceString; if (temp == "")
{
temp += addString; }
public string AddItemReversed(string sourceString, string addString)
{
string temp = sourceString; if (temp == "")
{
temp += addString; }
public string RandomItemInString(string pstr) {
int roundDirection; string temp1 = pstr; string temp2 = "";
LAMPIRAN D
D-2-
{
roundDirection = Random.Range(1, 3); if (roundDirection == 1)
{
temp2 += GetItemPos(temp1, front); front += 1;
} else {
temp2 += GetItemPos(temp1, last); last -= 1;
public int GetItemCount(string pstr) {
int temp = 1;
if (pstr == "") return temp; int maxChar = pstr.Length;
for (int i = 0; i < maxChar; i++) {
if (pstr.Substring(i, 1) == ",") {
public string GetItemPos(string pstr, int pos) {
string temp = ""; int count = 1;
int maxChar = pstr.Length;
for (int i = 0; i < maxChar; i++) {
LAMPIRAN D
D-3-
{
temp += pstr.Substring(i, 1); }
}
if ((count + 1) < pos) temp = ""; return temp;
LAMPIRAN E
E-1-
using UnityEngine;
using System.Collections;
public class tesKlik5 : MonoBehaviour { // Use this for initialization void Start () {
}
// Update is called once per frame void Update () {
}
public void OnMouseDown1() {
Application.LoadLevel("Gameplay"); }
LAMPIRAN F
F-1-
using UnityEngine; using UnityEngine.UI; using System.Collections;
public class Timer : MonoBehaviour { // Use this for initialization public Text timerText;
public Text timerText2; private float startTime;
private bool finished = false; private float t1024;
void Start () {
startTime = Time.time; }
// Update is called once per frame void Update () {
if (finished == true)
Time.timeScale=0; else {
float t = Time.time - startTime;
string minutes = ((int)t / 60).ToString ();
string seconds = (t % 60).ToString ("f2");
timerText.text = minutes + ":" + seconds;
} }
public void Finish() {
finished = true;
timerText.color = Color.red; }
public void Catat() {
if (t1024 == 0) {
float t = Time.time - startTime;
string minutes = ((int)t / 60).ToString ();
string seconds = (t % 60).ToString ("f2");
timerText2.text = minutes + ":" + seconds;
t1024++; } }
Nama : Devina Pratiwi Halim
Tempat, tanggal Lahir : Medan, 16 Mei 1992
Jenis Kelamin : Perempuan Umur : 24 tahun
Tinggi, berat badan : 158cm , 55 kg
Agama : Buddha
Alamat : Jalan Brig. Jend. Katamso GG. Baru No. 16 Medan
Status : Belum Kawin
Telepon : 085767658992
Email : devinapratiwihalim@gmail.com
Formal
1998 – 2004 : Lulusan SD Methodist 2 Medan 2004 – 2007 : Lulusan SMP Methodist 2 Medan 2007 – 2010 : Lulusan SMA Methodist 2 Medan 2012 – 2015 : Bachelor Jurusan Administrasi dan Finansial di Net Academy 2012 – 2016 : S1 Jurusan Akuntansi di Professional Management College
Indonesia
2014 : Associate Chartered Financial Practitioner(AChFP) di Asia Pacific Financial Services Association
2015
Pacific Financial Services Association
Data Pribadi
Latarbelakang Pendidikan :
Non Formal
2006 – 2007 : Bimbingan bahasa Inggris di The British Institute
2007 – 2008 : Bimbingan Matematika di AXIS
2009 : Bimbingan 1 Tahun Program Komputer di VISITEK
2010 : Workshop Teknik Dasar Fotografi di Ikatan Mahasiswa S1 Ilmu Komputer USU
2010 : Workshop Teknik Hacking di Ikatan Mahasiswa S1 Ilmu Komputer USU
2010 : Workshop Setting Cisco Router di WEBMEDIA Training Center
2011 : Panitia Seminar Teknologi Informasi di Universitas Sumatera Utara
2012 : Peserta Lomba Problem Solving IMILKOM Contest 2012
2013 : Partisipasi dalam Galang Dana Lions Club
2013 : Workshop Mengenal Kopi di Starbucks Medan
2013 : Partisipasi dalam Seminar Orang Yang Kaya Orang Yang Kreatif dari Professional Management College Indonesia
2015 : Liasion Officer (LO) Kegiatan Forum Rektor Indonesia XVII di Universitas Sumatera Utara
2016 : Volunteer dalam partisipasi Education Expo
• 2006 – 2007 : Anggota dari Klub Teater Methodist 2 Medan
• 2010 – 2012 : Anggota dari Keluarga Mahasiswa Buddhis di Universitas Sumatera Utara
• 2013 – 2014 : Anggota dari Singing Club di Professional Management College Indonesia
• 2014 – 2015 : Pengurus Badan Eksekutif Mahasiswa di Professional Management College Indonesia dengan jabatan Hubungan Masyarakat Eksternal
• 2002 : Penghargaan sebagai Juara X Reading-A di Language School Best
• 2007 : Penghargaan sebagai Peserta dalam mengikuti Pekan Olimpiade Sekolah
• 2008 : Penghargaan sebagai Juara II Kelas XI
• 2008 : Penghargaan sebagai peserta dalam mengikuti Lomba Sains Plus Antar Pelajar SMA Se-Sumut
• 2008 : Penghargaan sebagai Peserta dalam mengikuti Pekan Olimpiade Sekolah
• 2009 : Penghargaan sebagai Peserta dalam Pekan Olimpiade Sekolah
• 2009-2010 : Bekerja di Leny English Private Classes sebagai asisten pengajar bahasa Inggris
• Praktek Kerja Lapangan:
Praktek Kerja Lapangan di di Kantor Pelayanan Perbendaharaan Negara Medan Periode : Agustus 2013 – Oktober 2013
Tujugan : Mata Kuliah Wajib
Posisi : Konsultan IT dan Programmer Rincian Pekerjaan:
• Memasang jaringan pada satu ruangan
• Memasukkan biografi pegawai secara online pada website yang baru
• Mengorganisir data 10 tahun dan lebih dan menyusunnya sehingga dapat di akses seluruh departemen
• Membangun sebuah program dengan menggunakan Microsoft Excel untuk menangani pembayaran gaji pada semua unit di dalam departemen.
• 2014 : Bekerja di Scholars Hub sebagai pengajar sampai sekarang
• 2015 : Bekerja sebagai Agen Asuransi untuk Asuransi Panin Life Dai-ichi sampai sekarang
Penghargaan
• Kemampuan Komputer
Office
1. Microsoft Word 2. Microsoft Excel 3. Microsoft Power Point 4. Microsoft Access
Design & Video
1. Adobe Photoshop 2. Adobe Dreamweaver
Pemrograman
1. Visual Studio 2. Eclipse 3. Visual Basic 4. Unity 5. MatLab 6. FoxPro
Medan, 2 Nopember 2016
Hormat saya,
Devina Pratiwi Halim
36
DAFTAR PUSTAKA
Coppin, Ben. 2004. AI Illuminated. United States of America: Penerbit Jones and
Bartlett Publishers.
Ekaputra, V., Panggabean, F. & Satria, T. 2014. Analisis dan Perancangan Aplikasi
Game Multiplayer Life Simulaton Pet Master menggunakan Game Engine Unity 3D.
Skripsi. Jakarta: Binus University.
Hayuningtyas, Nastiti. 2014. Aplikasi Game Edukasi Supermath Berbasis Android.
Skripsi. Jakarta: Binus University.
Johannes, Frits. 2014. Aplikasi Game Survival Horror The Sight pada PC
menggunakan Unity 3D. Skripsi. Jakarta: Binus University.
Kyaw, A., Peters, C. & Swe, T. 2013. Unity 4.x Game AI Programming. E-Book.
Birmingham: Packt Publishing.
Karam, P. 2012. Artificial Intelligence. New York: Penerbit Chelsea House.
Maulina, E. & Satyaputra, A. 2014. Beginning Android Programming with ADT
Bundle. Jakarta : PT. Elex Media Komputindo.
Murya, Yosef. 2014. Pemrograman Android BlackBox. Jakarta : Jasakom.
Norvig, P. & Russell, S. 2010. Artificial Intelligence A Modern Approach. Third
Edition. New Jersey: Prentice Hall.
Suyanto. 2007. Artificial Intelligence. Bandung: Informatika Bandung.
Unity. Diakses 30 November 2014
Fitur – Fitur Unity. Diakses 30 Novembe 2014
16
BAB 3
ANALISIS DAN RANCANGAN
3.1 Analisis
Pencarian solusi dilakukan dengan menggunakan metode Generate and Test
melakukan pencarian solusi dengan cara membuat terlebih dahulu semua
kemungkinan langkah kemudian melakukan langkah terbaik. Pada penelitian ini
penulis merancang pencarian untuk tujuan mencapai nilai 2048.
3.1.1 Analisis Masalah (Problem Analysis)
Untuk mengidentifikasi masalah digunakan diagram Ishikawa (fishbone
diagram). Diagram Ishikawa adalah sebuah alat grafis yang digunakan untuk
membantu mengidentifikasi, mengeksplorasi dan menggambarkan suatu masalah serta
sebab dan akibat dari masalah tersebut. Diagram ini juga sering disebut sebagai
diagram sebab-akibat atau diagram tulang ikan. Identifikasi terhadap permasalahan
akan membantu analisis persyaratan sistem yang nantinya akan dikembangkan.
Masalah utama yang mendapat perhatian adalah mendapatkan nilai tertinggi
untuk blok yang diinginkan. Selanjutnya masalah ini diuraikan ke dalam beberapa
kategori seperti pada Gambar 3.1.
l
Gambar 3.1 Diagram Ishikawa untuk Analisis Permasalahan Sistem
Mencapai poin 2048
Machine
Generate and Test 2048
Man
Kemampuan prosesor yang
terbatas Menjalankan program dan
memantau program
Mengenal objek permainan
Tidak kehabisan langkah
Gameplay
Menjalankan langkah terbaik yang telah digenerate
17
Pada diagram Ishikawa diatas masalah utama ditunjukkan oleh segi empat paling
kanan (kepala ikan), sedangkan kategori ditunjukkan oleh segi empat yang
dihubungkan oleh sebuah garis ke tulang utama (garis horizontal yang terhubung ke
kepala ikan). Selanjutnya sebab akibat yang muncul ditunjukkan oleh tulang-tulang
kecil yang diwakili oleh garis panah yang mengarah ke tulang-tulang kategori
masalah.
3.1.2 Analisis Persyaratan (Requirement Analysis)
Analisis persyaratan sebuah sistem dikelompokkan ke dalam dua bagian besar
yaitu, analisis persyaratan fungsional dan analisis persyaratan non-fungsional.
3.1.2.1 Persyaratan Fungsional
Persyaratan fungsional yang harus dipenuhi oleh sistem adalah segala sesuatu
yang harus dimiliki oleh sistem. Sistem harus dapat membangkitkan langkah dan
menentukan langkah terbaik kemudian menjalankan langkah tersebut.
3.1.2.2 Analisis Persyaratan Non-Fungsional
Persyaratan non-fungsional adalah persyaratan apa yang harus dilakukan
sistem. Seringkali berupa batasan atau sesuatu yang menjadi perhatian stakeholder
sebuah sistem. Beberapa persyaratan non-fungsional yang harus dipenuhi oleh sistem
yang dirancang adalah sebagai berikut:
1. Performa
Sistem atau perangkat lunak yang akan dibangun harus dapat menampilkan
setiap langkah yang diambil dalam waktu yang cepat.
2. Mudah digunakan (User friendly)
Sistem yang akan dibangun harus user friendly, artinya bahwa sistem mudah
digunakan oleh user dengan tampilan (interface) yang sederhana dan mudah
dimengerti.
3. Hemat Biaya Sistem atau perangkat lunak yang digunakan tidak memerlukan
18
4. Dokumentasi Sistem yang akan dibangun harus bisa menyimpan total waktu
yang diambil secara akurat.
5. Kontrol Sistem yang akan dibangun harus dapat menampilkan kotak dialog
selesai ketika target telah tercapai dan menampilkan kotak dialog gagal ketika
proses gagal.
6. Manajemen Kualitas Sistem atau perangkat lunak yang akan dibangun harus
memiliki kualitas yang baik yaitu dapat membangkitkan langkah secara tepat
serta dapat menghitung nilai Running Time .
3.2 Pemodelan Perangkat Lunak
Pemodelan perangkat lunak dilakukan untuk memperoleh gambaran yang lebih
jelas tentang objek apa saja yang akan berinteraksi dengan sistem serta hal-hal apa
saja yang harus dilakukan oleh sebuah sistem sehingga sistem dapat berfungsi dengan
baik sesuai dengan fungsionalitasnya.
Perancangan fungsionalitas pemilihan solusi 2048 akan dikembangkan dan
dimodelkan dengan diagram use-case. Actor yang nantinya akan berinteraksi dengan
sistem adalah human. Human dikategori sebagai entitas yang akan menjalankan
program dan mencatat hasil solusi yang dibangkitkan (generated).
3.2.1 Use-Case Diagram
Use-case diagram merupakan diagram yang memodelkan perilaku dari sebuah
sistem. Use-case diagram memiliki actor use-case dan interaksi apa saja yang
dilakukan actor tersebut.
Use-case untuk metode Generate and Test dapat dilihat seperti pada Gambar
19
Gambar 3.2 Use Case Generate and Test
Pada diagram Gambar 3.2 tersebut tampak bahwa seorang User (pengguna)
hanya bekerja dengan mengakses use-case sistem pencarian jarak terpendek
menggunakan metode Generate and Test. Pengguna tidak perlu mengetahui secara
jelas proses apa saja yang terjadi pada setiap tahap. Dengan demikian untuk
memutuskan proses apa yang nantinya dilakukan pada setiap tahap adalah menjadi
tanggung jawab sistem.
3.2.1.1 Use Case Generate and Test
Spesifikasi use case Generate and Test dapat dilihat pada Tabel 3.1
Tabel 3.1. Spesifikasi Use Case Generate and Test
Name Generate and Test
Actors System
20
Precondition Pengguna menekan button mulai pada tampilan awal sistem
Post Condition Program mulai menjalankan proses dan menampilkan
langkah-langkah yang diambil sistem
Success Scenario 1. Pengguna menekan tombol start
2. Sistem menampilkan halaman generate and test
3. Sistem menjalankan perhitungan dan menampilkan
langkah-langkah yang diambil
4. Sistem mencapai nilai 2048
Alternative Flows 1. Pengguna menekan tombol start
2. Sistem menampilkan halaman generate and test
3. Sistem menjalankan perhitungan dan menampilkan
langkah-langkah yang diambil
4. Sistem kehabisan langkah dan berhenti
3.2.2 Activity Diagram
Activity diagram merupakan gambaran dari alur aktivitas sistem. Berikut ini
21
Gambar 3.3 Activity Diagram Generate and Test
3.2.3 Sequence Diagram
Proses pencarian jarak terpendek menggunakan metode Generate and Test
adalah dengan melakukan pembangkitan rute-rute dengan DFS (Depth First Search),
Backtracking serta proses pencarian serta informasi hasil pencarian jarak terpendek
yang dalam penelitian ini digambarkan sebagai sequence diagram seperti pada
22
Gambar 3.4 Sequence Diagram Generate and Test
3.3 Flowchart Sistem
Berdasarkan penjelasan sebelumnya, maka dapatlah digambarkan flowchart
metode Generate and Test dalam mencari jarak terpendek dapat dilihat seperti pada
23
Gambar 3.5 Flowchart Sistem
n = bilangan bulat (jumlah rute backtracking) (1,2,3 …) Begin
Terminate?
I<7 I = 1
I ++
Simpan posisi langkah yang akan keluar
Generate block baru & simpan posisinya
END Y
Y N
N
Tentukan langkah terbaik dan lakukan langkah terbaik
Mencapai 2048
24
3.3.1 Flowchart menentukan langkah terbaik
Gambar 3.6 Flowchart Langkah Terbaik 3.4 Pseudocode Sistem
Untuk lebih memahami sistem yang akan dibuat, maka berikut pseudocode program
AI dari sistem yang akan dibuat. Dalam pembuatan AI generate and test terdapat 3
buah prosedur utama untuk membangkitkan langkah dan menjalankan langkah
terbaik,yaitu
1. Reset Node();
2. ContinueAI();
Pdeudocode reset node adalah sebagai berikut:
1. for (int i = 0; i < myNode.Length; i++) Begin
Mengambil posisi dan angka yang digenerate
Menentukan langkah yang menyisakan banyak kotak kosong
End
Menentukan langkah dengan nilai tertinggi
25
2. {
3. myNode[i].intAngkaTinggi = 0; 4. myNode[i].intSisaKotak = 0; 5. myNode[i].intPosisiKeluar = -1; 6. myNode[i].BoardAktif = ""; 7. myNode[i].isIdle = false; 8. }
9. strSaveDataAIArah = ""; 10. strSaveDataAISpawn = "";
11. for (int j = 0; j < strRandSpawn6.Length; j++) strRandSpawn6[j] = myModule.RandomItemInString("0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"); 12. ContinueAI();
13. }
Keterangan:
Tujuan dari prosedur ini adalah untuk mereset semua variabel yang telah dibangkitkan
pada langkah sebelumnya. Semua variabel yang akan digunakan akan dikosongkan
kemudian prosedur Continue AI akan dibangkitkan. Berikut merupakan detail
penjelasan pseudocode untuk prosedur reset():
1) for (int i = 0; i < myNode.Length; i++)
myNode.Length merupakan jumlah panjang dari node yang dibangkitkan (generated).
Untuk setiap node, dilakukan pembersihan untuk variabel yang terbentuk.
2) Untuk baris 2 sampai 7 merupakan variabel yang akan mereset node yang
digunakan.
a. myNode[i].intAngkaTinggi merupakan array variabel untuk menampung nilai tertinggi dalam permainan;
b. myNode[i].intSisaKotak merupakan array variabel untuk menyimpan jumlah kotak kosong yang terdapat dalam permainan;
c. myNode[i].intPosisiKeluar merupakan array variabel untuk menyimpan posisi kotak baru yang akan ditampilkan;
d. myNode[i].BoardAktif merupakan array variabel untuk menyimpan posisi object yang merupakan hasil dari pembangkitan sebelumnya;
e. myNode[i].isIdle merupakan array boolean yang akan menampung nilai object ketika tidak bergerak dari posisi sebelumnya
3) strSaveDataAIArah merupakan array variabel untuk menyimpan arah yang akan ditempuh.
4) strSaveDataAISpawn merupakan array variabel untuk menyimpan tempat posisi kotak baru yang akan keluar.
26
6) Pemanggilan prosedur continue ai
Pseudocode ContinueAI() adalah sebagai berikut:
1)for (int k = 0; k < myNode.Length; k++) 11)int intAngkaTinggi = 0; 12)int intSisaKotak = 0;
13)for (int v = 340; v < myNode.Length; v++) 14){
15)if (!myNode[v].isIdle && ((intAngkaTinggi < myNode[v].intAngkaTinggi) || (intAngkaTinggi == myNode[v].intAngkaTinggi && intSisaKotak < myNode[v].intSisaKotak)))
16){
17)getTmpIdx = v;
18)intAngkaTinggi = myNode[v].intAngkaTinggi; 19)intSisaKotak = myNode[v].intSisaKotak; 20)}
21)}
22)for (int w = 5; w > 0; w--) 23){
24)strSaveDataAIArah =
myModule.AddItemReversed(strSaveDataAIArah, myNode[getTmpIdx].strArah);
25)strSaveDataAISpawn =
myModule.AddItemReversed(strSaveDataAISpawn, myNode[getTmpIdx].intPosisiKeluar.ToString()); 26)for (int x = 0; x < myNode.Length; x++)
27){
28)if (myNode[x].strNodeId == myNode[getTmpIdx].strNodeIdParent) 29){
30)getTmpIdx = x; 31)}
32)} 33)}
27
Keterangan:
Tujuan dari prosedur continueAI adalah untuk menyimpan array langkah
kemudian memilih langkah terbaik kemudian melakukan trace up untuk langkah yang
terbaik.
3.5 Perancangan Antarmuka Pengguna (User Interface)
Dalam membangun sebuah sistem perlu adanya perancangan antarmuka (User
Interface) yang nantinya sangat membantu memudahkan pengoperasian sistem.
Dalam merancang antarmuka pengguna, ada beberapa syarat yang harus dipenuhi agar
tercipta sebuah perangkat lunak yang mudah dan informatif untuk pengguna (user
friendly).
Gambar 3.7 Rancangan Tampilan Pertama
Keterangan:
1. Tampilan Judul program
2. Button Start yang akan menjalankan proses Generate and Test
3. Tampilan nama dan identitas pembuat program.
Tampilan menu utama hanya memiliki 1 Button yaitu tombol Start untuk
memulai dan berisi tentang beberapa informasi tentang pembuat program. Ketika
tombol Start ditekan maka akan dilanjutkan langsung pada tampilan permainan. 1
2
28
BAB IV
IMPLEMENTASI DAN PENGUJIAN SISTEM
4.1 Implementasi Sistem
Setelah melakukan proses analisis dan perancangan sistem, proses selanjutnya
dalam penerapan pembuatan aplikasi adalah proses implementasi dan pengujian
sistem. Implementasi merupakan tahap di mana sistem melakukan fungsionalitas
utamanya setelah suatu program atau perangkat lunak selesai dirancang, sedangkan
tahap pengujian merupakan tahap yang dilakukan setelah proses pengimplementasikan
selesai dilakukan dan sampai proses uji coba sesuai dengan kriteria-kriteria yang
diinginkan pengguna pada tahap perancangan sistem.
4.1.1 Tampilan permainan
Tampilan permainan merupakan tampilan untuk melakukan semua proses
pengimplementasian proses generate and test dan pengambilan n langkah terbaik
dalam permainan. Dimana n yang digunakan adalah 5 dan 6. Berikut ini pada gambar
4.1 menampilkan contoh tampilan permainan:
Gambar 4.1 Tampilan permainan (gameplay scene)
2
3
1
29
Keterangan:
1. Judul yang menampilkan nama program yang sedang dijalankan.
2. Tampilai User Interface yang akan menunjukan waktu ketika 1024 telah
dicapai.
3. Tampilan User Interface untuk waktu yang sedang berjalan dan akan
berhenti ketika telah mencapai 2048 atau program kehabisan langkah.
4. Panel merupakan tempat Game Object akan ditampilkan.
Pengujian dianggap berhasil jika dalam hasil pengerjaannya, program
menunjukkan nilai 2048 pada kotak yang ada dan adanya pengukuran waktu yang
dihentikan segera. Berikut contoh hasil program generate and test 5 langkah yang
mampu berhasil yang dilakukan pada android:
Gambar 4.2 Tampilan berhasil
Suatu pengujian dianggap gagal apabila program mempunyai grid yang sudah
penuh dan ditandai dengan permainan tidak dapat dijalankan lagi karena langkah
berikutnya sudah tidak dapat dibangkitkan. Pada gambar 4.3 terlihat contoh pengujian
5 langkah yang tidak mampu mencapai 2048 dan pengukuran waktu dihentikan pada
30
Gambar 4.3 Tampilan gagal
4.2 Perhitungan Manual
Adapun perhitungan manual yang dilakukan dalam pengerjaan sistem ini
adalah untuk menentukan berapa banyak iterasi yang dilakukan untuk membangkitkan
langkah yang ada.
Berikut ilustrasi langkah yang dapat dilakukan untuk 2 langkah berturut.
31
Dari ilustrasi tersebut dapat dilihat bahwa untuk pembangkitan langkah dari
parent terdapat 4 buah langkah yang mungkin sedangkan untuk langkah berikutnya
dibutuhkan lagi masing – masing 4 langkah yang mungkin dengan total 16 langkah.
Jumlah iterasi yang perlu dilakukan untuk 2 buah langkah adalah 16+4=20. Sehingga
untuk menghitung jumlah iterasi dilakukan 4n + 4n-1 + 4n-2 +...+ 4n-n.
Pada tabel 4.1 ditunjukkan hasil perhitungan jumlah iterasi yang perlu
dilakukan untuk n buah langkah.
Tabel 4.1 Hasil perhitungan jumlah iterasi untuk n buah langkah
N 4n Perhitungan Total
1 4 4 4
2 16 4+16 20
3 64 20+64 84
4 256 84+256 340
5 1024 340+1024 1364
6 4096 1364+4096 5460
7 16384 5460+16384 21844 8 65536 21844+65536 87380 9 262144 87380+262144 349524 10 1048576 349524+1048576 1398100
4.3 Pengujian Sistem
Pada pengujian sistem permainan puzzle 2048, akan dilakukan proses generate
5 langkah dan 6 langkah untuk kemudian dibandingkan waktu kecepatan rata-rata dan
nilai keberhasilan rata-rata dari masing-masing proses. Pengujian dilakukan pada
perangkat android dan simulator yang sudah tersedia pada Unity 3D.
Dalam pengujiannya untuk mengambil data, maka program akan dijalankan
sebanyak 10 kali untuk dihitung rata-ratanya untuk kemudian dibandingkan hasilnya.
Berikut tabel 4.2 untuk menunjukan seluruh hasil pengukuran waktu solusi 2048
32
Tabel 4.2 Hasil pengujian program terhadap waktu dan keberhasilan program dengan 5 langkah
Percobaan
Dari hasil pengujian program generate and test 5 langkah, dapat dilihat bahwa
persentase keberhasilan pada program semuanya dapat mencapai nilai 1024 dengan
waktu rata-rata 3 menit 12 detik. Dengan program terminated pada waktu rata-rata 6
menit 30 detik. Dari tabel 4.1 terlihat bahwa keberhasilan pada program 5 langkah
hanya mencapai 30% dengan catatan program terminated pada saat 1024 dan 512
sudah terlihat.
Dari hasil tersebut didapatkan bahwa metode tersebut kurang andal dalam
mencari solusi sehingga pengujian dilakukan pada pembangkitan 6 langkah. Hasil
pengukuran waktu untuk generate and test 6 langkah ditunjukan oleh tabel berikut:
Tabel 4.3 Hasil pengujian program terhadap waktu dan keberhasilan program dengan 6
33
9 0:05:00 0:09:13 Berhasil 10 0:04:42 0:08:51 Gagal
Rata-rata 0:04:39 0:09:08 70%
Dari hasil pengujian program generate and test 6 langkah, dapat dilihat bahwa
persen keberhasilan pada program semuanya dapat mencapai nilai 1024 dengan waktu
rata-rata 4 menit 39 detik serta mampu mencapai 2048 dengan waktu rata-rata 9 menit
8 detik. Dapat dilihat pula dari tabel 4.2 bahwa keberhasilan pada program 6 langkah
mencapai hingga 70%.
Jika dibandingkan, program 5 langkah mampu mencapai 1024 dengan waktu
yang lebih singkat jika dibandingkan program 6 langkah, namun untuk mencapai
2048, program 5 langkah hanya memiliki 3 keberhasilan dari 10 percobaan. Berikut
grafik perbandingan waktu mencapai 1024 pada program 5 langkah dan 6 langkah:
Gambar 4.6 Grafik perbandingan waktu mencapai 1024
Pada gambar 4.6, dapat dilihat bahwa pada setiap percobaan yang telah
dilakukan, adanya waktu yang berlebihan dalam penyelesaian permainannya pada
langkah ke – 6. Setelah dirata- ratakan waktu yang telah dicatat dan di ambil dari
kedua tabel 4.2 dan tabel 4.3, maka akan didapatkan kelebihan waktu 1 menit 20 detik
antara kedua buah langkah.
Pada langkah ke 6 dan langkah ke 5, dapat dilihat bahwa keduanya selalu
34
membuktikan bahwa sampai dengan 1024, penggu naan langkah ke 5 akan cukup
efektif dikarenakan waktu yang didapatkan lebih cepat dibandingkan dengan langkah
ke 6. Namun, pencapaian permainan 1024 merupakan separuh jalan dalam
menyelesaikan permainannya. Oleh karena itu, diharuskan untuk dibandingkan dalam
pencapaian hasil akhirnya yaitu 2048.
Gambar 4.7 Grafik perbandingan waktu mencapai 2048
Pada Gambar 4.7 diatas, dapat dilihat bahwa perbandingan waktu langkah ke 5
dan langkah ke 6 sangatlah berbeda. Pada 10 percobaan yang telah dilakukan untuk
mencapai 2048, langkah ke 6 membuktikan adanya pencapaian yang lebih baik dalam
menyelesaikan permainan puzzle 2048. Langkah ke 5 memberikan waktu yang lebih
cepat namun keberhasilan dalam penyelesaiannya sangat rendah.
Oleh karena itu, meski lebih cocok untuk 1024, langkah ke 5 tidak dapat
diterapkan untuk menyelesaikan permainan 2048 hingga selesai. Di perlukan langkah
ke 6 untuk memastikan keberhasilan permainan 2048 sampai akhir. Langkah ke 6
35
BAB V
KESIMPULAN DAN SARAN
5.1. Kesimpulan
Berdasarkan pengujian sistem yang telah dilakukan, dapat diambil beberapa
kesimpulan, yaitu:
1. Metode Generate and Test dapat digunakan untuk mencari solusi dalam
menyelesaikan game puzzle 2048.
2. Semakin banyak iterasi yang digunakan dalam penentuan langkah selanjutnya,
maka kemungkinan untuk menyelesaikan game puzzle 2048 semakin besar.
3. Waktu dalam menyelesaikan game puzzle 2048 akan bertambah dan berjalan
semakin lambat jika iterasi yang digunakan semakin besar
5.2. Saran
Berdasarkan dari kesimpulan di atas, maka penulis memberikan beberapa saran
untuk pengembangan sistem ini selanjutnya, yaitu:
1. Diharapkan agar metode Generate and Test dapat dibandingkan dengan metode
lainnya seperti Algoritma MiniMax yang sering dipakai untuk menyelesaikan
game puzzle 2048.
2. Diharapkan agar game puzzle 2048 dapat diimplementasikan pada platform yang
berbeda untuk dibandingkan dengan platformAndroid yang digunakan pada
penelitian ini.
3. Diharapkan agar iterasi yang lebih tinggi dapat di percepat waktu perhitungannya
9
BAB 2
TINJAUAN PUSTAKA
2.1. Kecerdasan Buatan
Kecerdasan buatan (artificial intelligence), yang disingkat AI, merupakan
salah satu cabang dalam ilmu komputer yang mempelajari tentang bagaimana
membuat komputer menyelesaikan suatu masalah sebaik yang dapat dilakukan
oleh manusia.
Kecerdasan buatan adalah sebuah teknologi yang baru muncul pada
dekade ini dengan banyak aplikasi terapan yang sedang berkembang. Salah satu
pandangan dalam kecerdasan buatan berhubungan tentang cara membuat
komputer menjadi lebih pintar. Sehingga penelitian pada kecerdasan buatan
berfokus pada 2 hal, yaitu:
1. Membuat mesin lebih berguna
2. Memahami kecerdasan
Masalah dalam pengembangan kecerdasan buatan umumnya berkaitan
dengan cara mengenal proses yang kompleks, tidak pasti dan ambigu. Proses
yang tidak memiliki penyelesaian secara algoritma dan membutuhkan suatu
metode penyelesaian yang mengikuti pola pemikiran manusia dan hewan untuk
mengatasi masalah yang kompleks. (Coppin, 2004)
Manusia pandai dalam menyelesaikan permasalahan karena manusia
memiliki kemampuan merasakan indera (sentience) dan kecerdasan
(Inteligence).Untuk menirukan kemampuan indera manusia, komputer dapat
dihubungkan dengan sebuah kamera atau scanner sehingga dapat melihat seperti
manusia. Komputer juga dipasangkan sensor seperti microphone dan dapat
10
Untuk mendapatkan kemampuan merasakan, komputer dapat dihubungkan
dengan sensor yang tepat.
Kecerdasan sering didefiniskan sebagai kemampuan untuk mempelajari.
Kemampuan manusia untuk mempelajari dapat dilakukan karena manusia
mempunyai pengetahuan dan pengalaman.Pengetahuan diperoleh dari
belajar.Semakin banyak bekal pengetahuan yang dimiliki, seseorang diyakini lebih
mampu dalam menyelesaikan permasalahan.Namun, bekal ilmu pengetahuan saja
tidaklah cukup jika manusia tidak diberikan akal untuk melakukan penalaran yang
digunakan untuk mengambil kesimpulan berdasarkan pengalaman dan pengetahuan
yang dimiliki. Tanpa memiliki kemampuan untuk menalar dengan baik, manusia
dengan sejumlah pengalaman dan pengetahuan tidak akan dapat menyelesaikan
masalah dengan baik. Demikian juga dengan kemampuan menalar yang sangat
baik, namun tidak memiliki pengetahuan dan pengalaman yang memadai,
seseorang tidak akan bisa menyelesaikan masalah dengan baik.
Mesin diciptakan untuk membantu manusia dalam menyelesaikan dan
membantu manusia didalam kesehariannya.Dengan demikian, mesin juga
diharapkan dapat menjadi cerdas yaitu dapat bertindak seperti dan sebaik
manusia.Diharapkan bahwa aplikasi komputer atau mesin yang dibuat dan
diciptakan dapat menjadi lebih pintar dan mudah dalam penggunaannya serta
ditingkatkan lagi dalam efisiensi penggunaannya.Oleh karena itu, mesin diberikan
pengetahuan sehingga mempunyai kemampuan untuk menalar dengan
baik.(Karam, 2012)
Pengertian kecerdasan buatan dapat dipandang dari berbagai sudut
pandang, antara lain:
1. Sudut pandang kecerdasan
Kecerdasan buatan akan membuat mesin menjadi cerdas (mampu berbuat
seperti apa yang dilakukan oleh manusia).
2. Sudut pandang penelitian
Kecerdasan buatan adalah suatu studi bagaimana membuat agar komputer
dapat melakukan sesuatu sebaik yang dikerjakan oleh manusia.
11
Kecerdasan buatan adalah kumpulan peralatan yang sangat kuat dan
metodologis dalam menyelesaikan masalah- masalah bisnis.
4. Sudut pandang pemrograman
Kecerdasan buatan meliputi studi tentang pemrograman simbolik,
penyelesaian masalah dan pencarian.Dalam pembuatan aplikasi kecerdasan buatan,
ada dua bagian utama yang sangat dibutuhkan, yaitu:
a. Basis pengetahuan (Knowledge Base), bersifat fakta- fakta, teori,
pemikiran dan hubungan antar satu dengan yang lainnya.
b. Motor Inferensi (Inference Engine), kemampuan menarik
kesimpulan berdasarkan pengetahuan dan pengalaman.
2.1.1 Turing Test
Untuk menentukan apakah suatu kecerdasan buatan sudah mendekati
kemampuan manusia dan dapat disebut ‘cerdas’, dilakukan suatu percobaan yang
disebut Turing Test yang ditemukan oleh Alan Turing pada tahun 1950, seorang
pioneer AI dan ahli matematika asal Inggris yang melakukan experiment dengan
menempatkan AI di satu terminal dan terminal lainnya dikendalikan oleh manusia.
Kedua terminal ini ditempatkan di posisi berjauhan. Manusia tersebut berkomunikasi
dengan komputer tersebut dan mengira bahwa lawan komunikasinya adalah manusia
juga. Menurut Turing jika seseorang bisa salah mengira komputer sebagai manusia,
maka komputer tersebut bisa dikatakan ‘cerdas’.
Untuk dapat lolos Turing Test, komputer harus setidaknya memiliki kemampuan
untuk melakukan beberapa proses berikut:
A. Natural language processing, yaitu kemampuan komputer agar dapat
berkomunikasi dengan lancar dengan struktur bahasa yang natural.
B. Knowledge representation, yaitu kemampuan komputer menyimpan
informasi-informasi yang diterimanya dan bertindak sebagai pengetahuan komputer.
C. Automated reasoning, yaitu kemampuan komputer dalam mengolah informasi
12
D. Machine learning, yaitu kemampuan komputer untuk mempelajari hal baru
dan beradaptasi terhadap hal yang baru. Cara paling sederhana dalam
machine learning adalah dengan mencoba dan gagal (trial and error).
Selain Turing Test, terdapat Total Turing Test yang membutuhkan 2 proses
tambahan selain 4 proses yang telah disebutkan untuk dapat lolos tes ini. Agar dapat
lolos, sebuah komputer juga harus mampu melakukan 2 proses berikut:
A. Computer vision, dimana komputer harus mampu melihat dan
menginterpretasikan objek.
B. Robotics, dimana komputer mampu memanipulasi objek dan dapat
bergerak.(Norvig,2010)
2.2 Bidang-bidang Terapan pada Kecerdasan Buatan
Berikut beberapa bidang terapan yang dapat dihubungkan dengan kecerdasan
buatan:
a. Sistem pakar (expert system)
Sebuah sistem komputer yang digunakan sebagai sarana untuk menyimpan
pengetahuan yang dimiliki oleh seorang pakar dengan tujuan agar komputer
memiliki keahlian untuk menyelesaikan permasalahan dengan meniru keahlian
yang dimiliki pakar tersebut.
b. Pengolahan bahasa alami (natural language processing)
Pemrograman sistem komputer yang memungkinkan manusia berkomunikasi
dengan komputer dengan menggunakan bahasa sehari-hari.
c. Pengenalan suara (speech recognition)
Kemampuan membuat komputer agar dapat mengenali suara dan melakukan
perintah yang diberikan kepadanya melalui suara tersebut.
13
Kumpulan sistem yang mampu memanipulasi benda dan bergerak sesuai
dengan program di dalamnya dan dilengkapi berbagai sensor untu mendeteksi
pekerjaan secara otomatis.
e. Intelligence computer-aided instruction
Sistem komputer yang digunakan sebagai pengajar untuk manusia.
f. Computer vision
Pemrograman yang bertujuan untuk menginterpretasikan gambar dan objek
tampak melalui komputer untuk proses selanjutnya.
g. Game playing
Sistem permainan yang dilengkapi dengan kecerdasan buatan untuk bergerak
sendiri tanpa dikendalikan. AI akan menggerakan karakter dengan sendirinya
tanpa dikendalikan oleh pemain (Non-Player Character).
Dalam pembuatan AI dalam game playing dapat dilakukan dengan beberapa
cara, salah satunya adalah dengan menggunakan metode pencarian Heuristik.
2.3 Metode Pencarian Heuristik
Teknik pencarian heuristik (heuristic searching) atau dikenal juga dengan
rapid-prototyping merupakan suatu strategi untuk melakukan proses pencarian ruang
keadaan (state space) suatu problema secara selektif, yang memandu proses pencarian
yang kita lakukan disepanjang jalur yang memiliki kemungkinan sukses paling besar,
dan mengesampingkan usaha yang bodoh dan memboroskan waktu.
Heuristik merupakan sebuah teknik yang mengembangkan efisiensi dalam
proses pencarian, namun dengan kemungkinan mengorbankan kelengkapan
(completeness). Heuristik dapat diterapkan dengan baik dalam suatu domain tertentu
jika memiliki suatu fungsi heuristik, dimana fungsi heuristik ini digunakan untuk
mengevaluasi keadaan keadaan problema individual dan menentukan seberapa jauh
hal tersebut dapat digunakan untuk mendapatkan solusi yang diinginkan.
Jenis – jenis pencarian heuristik terdiri atas Generate and Test, Hill
Climbing, Best First Search, Alpha Beta Prunning, Means-End-Analysis, dan
14
Metode Generate and Testadalah metode yang paling sederhana dalam teknik
pembelajaran komputer.Metode ini menciptakan semua solusi yang mungkin
dikerjakan secara sistematis dengan aturan tertentu dan menjamin akan menemukan
solusi terhadap suatu masalah. Namun, jika ruang masalahnya sangat luas, mungkin
memerlukan waktu yang sangat lama.
Algoritma Generate And Test menggunakan prosedur Depth First
Search(DFS) karena suatu solusi harus dibangkitkan secara lengkap sebelum
dilakukan Test. Algoritma ini berbentuk sistematis, pencarian sederhana yang
mendalam dari suatu ruang permasalahan. Generate And Test juga dapat dilakukan
dengan pembangkitan solusi secara acak, tetapi tidak ada jaminan solusinya akan
ditemukan.
Di dalam Generate And Test, terdapat dua prosedur penting: pembangkit
(membangkitkan sebuah solusi yang mungkin) dan tes (menguji solusi yang
dibangkitkan tersebut). Dengan penggunaan memori yang sedikit, DFS bisa
digunakan sebagai prosedur Pembangkit yang menghasilkan suatu solusi. (Suyanto,
2007)
Contoh penyelesaian dengan menggunakan metode Generate and Test dapat
dilihat pada gambar 2.1 dan gambar 2.2. Gambar 2.1 merupakan contoh penggunaan
generate pada pencarian jalur, sedangkan gambar 2.2 merupakan contoh penggunaan
generate pada pencarian 5 langkah game 2048.
15
Gambar 2.2. Ilustrasi Alur Pencarian Generate and Test untuk pencarian 4
langkah
Dari kedua gambar tersebut, maka dapat dihasilkan tabel hasil langkah yang
mungkin untuk kemudian dilakukan langkah test. Tabel 2.1 menujukkan hasil langkah
test untuk panjang lintasan terpilih sebagai berikut:
Tabel 2.1 Tabel hasil lintasan terpendek menggunakan Generate and Test
Pencarian
Ke - Lintasan
Panjang
Lintasan
Lintasan
Terpilih
Panjang
Lintasan
Terpilih
1 ABCD 19 ABCD 19
2 ABDC 18 ABDC 18
3 ACBD 12 ACBD 12
4 ACDB 13 ACBD 12
5 ADBC 16 ACBD 12
Pada tabel 2.1 dapat dilihat bahwa jalur terpendek adalah melalui lintasan
ACBD dengan panjang lintasan 12. Maka langkah selanjutnya, AI akan menjalankan
16
2.3.1.1 Algoritma Generate and Test
Algoritma generate and test menurut (Suyanto, 2007) pada generate and test
adalah sebagai berikut:
1. Bangkitkan sebuah solusi yang mungkin. Solusi bisa berupa suatu keadaan(state).
2. Lakukan Testapakah solusi yang dibangkitkan tersebut adalah sebuah solusi yang
bisa diterima sesuai dengan kriteria yang diberikan.
3. Jika solusi telah ditemukan, keluar. Jika belum, kembali ke langkah 1. (Suyanto,
2007)
Sedangkan menurut (Kyaw, 2013), algoritma generate and test adalah sebagai
berikut:
Generate_and_test()
{
Begin:
Dijabarkan solusi yang memungkinkan;
Evaluasi solusi dengan membandingkannya dengan criteria yang telah
diterima;
If (solusi memuaskan dan sesuai dengan kriteria yang diinginkan) quit;
Else go to begin;
}
Dari kedua kutipan tersebut, dapat kita dapat menarik kesimpulan bahwa
algoritma generate and test terdiri dari proses pembangkitan (generate) dan pengujian
(test).
2.4 Unity
Unity merupakan suatu aplikasi yang digunakan untuk mengembangkan
game multi platform yang didesain agar mudah digunakan. Unity dipenuhi perpaduan
17
Editor pada Unity dibuat dengan user interface yang sederhana. Grafis pada unity
dibuat dengan grafis tingkat tinggi untuk OpenGL dan directX. Unity mendukung
semua format file, terutamanya format umum seperti semua format dari art
applications. Unity cocok dengan versi 64-bit dan dapat beroperasi pada Mac OS x
dan Windows dan dapat menghasilkan game untuk Mac, Windows, Wii, iPhone, iPad
dan Android.
Unity secara rinci dapat digunakan untuk membuat video game 3D,animasi
3D real timedan visualisasi arsitektur dengan isi serupa yang interaktif. Editor Unity
dapat menggunakan plugin web player dan menghasilkan game browser yang
didukung oleh Windows dan Mac. Plugin web player dapat juga dipakai untuk
widgets Mac. Unity juga akan mendukungconsole terbaru seperti PlayStation 3 dan
Xbox 360.
Server aset dari Unity dapat digunakan semua scripts dan aset game sebagai
solusi dari versi kontrol dan dapat mendukung proyek yang terdiri atas banyak
gigabytes dan ribuan dari file multi-megabyte. Editor Unity dapat menyimpan
metadata dan versi yang dapat berjalan, pembaharuan dan didalam perbandingan versi
grafis. Editor Unity dapat diperbaharui secara langsung seperti file yang telah
dimodifikasi. Server aset Unity juga cocok pada Mac, Windows dan Linux dan juga
berjalan pada PostgreSQL, database server opensource.
2.4.1Fitur-fitur pada Unity
Unity sebagai editor memiliki fitur-fitur seperti rendering, scripting, asset tracking,
multi-platform, asset store, physics engine yang akan turut membantu dalam
pengembangan aplikasi.
2.4.1.1 Rendering
Graphics engine yang digunakan adalah Direct3D (Windows, Xbox 360),
OpenGL (Mac, Windows, Linux, PS3), OpenGL ES (Android, iOS), dan proprietary
18
mapping, screen space ambient occlusion (SSAO), dynamic shadows using shadow
maps, render-to-texture and full-screen post-processing effects.
Unity dapat mengambil format desain dari 3Ds Max, Maya, Softimage,
Blender, modo, ZBrush, Cinema 4D, Cheetah3D, Adobe Photoshop, Adobe Fireworks
and Algorithmic Substance. Asset tersebut dapat ditambahkan ke game project dan
diatur melalui graphical user interface Unity.
ShaderLab adalah bahasa yang digunakan untuk shaders, dimana mampu
memberikan deklaratif “programming” dari fixed-function pipeline dan program
shader ditulis dalam GLSL atau Cg. Sebuah shader dapat menyertakan banyak varian
dan sebuah spesifikasi fallback declarative, dimana membuat Unity dapat mendeteksi
berbagai macam video card terbaik saat ini, dan jika tidak ada yang kompatibel, maka
akan digunakanshader alternatif yang mungkin dapat menurunkan fitur dan performa.
2.4.1.2 Scripting
Script game engine dibuat dengan Mono 2.6, sebuah implementasi
open-source dari .NET Framework.Programmer dapat menggunakan UnityScript (bahasa
terkustomisasi yang terinspirasi dari sintax ECMAScript, dalam bentuk JavaScript),
C#, atau Boo (terinspirasi dari sintaks bahasa pemrograman phyton).Dimulai dengan
dirilisnya versi 3.0, Unity menyertakan versi MonoDevelop yang terkustomisasi untuk
debug script.
2.4.1.3 Asset Tracking
Unity juga menyertakan Server Unity Asset – sebuah solusi terkontrol untuk
developer game asset dan script. Server tersebut menggunakan PostgreSQL sebagai
backend, sistem audio dibuat menggunakan FMOD library (dengan kemampuan untuk
memutar Ogg Vorbis compressed audio), video playback menggunakan Theora codec,
engine daratan dan vegetasi (dimana mendukungtree billboarding, Occlusion Culling
dengan Umbra), built-in lightmapping dan global illumination dengan Beast,
multiplayer networking menggunakan RakNet, dan navigasi mesh pencari jalur
19
2.4.1.4 Multi-Platforms
Unity support pengembangan ke berbagai plaform. Didalam project,
developer memiliki kontrol untuk mengirim keperangkat mobile, web browser,
desktop, and console. Unity juga mengijinkan spesifikasi kompresi textur dan
pengaturan resolusi di setiap platform yang didukung.
Saat ini platform yang didukung adalah BlackBerry 10, Windows 8,
Windows Phone 8, Windows, Mac, Linux, Android, iOS, Unity Web Player, Adobe
Flash, PlayStation 3, Xbox 360, Wii U and Wii. Meskipun tidak semua terkonfirmasi
secara resmi, Unity juga mendukung PlayStation Vita yang dapat dilihat pada game
Escape Plan dan Oddworld: New ‘n’ Tasty.
2.4.1.5 Asset Store
Diluncurkan November 2010, Unity Asset Store adalah sebuah resource yang
hadir di Unity editor. Asset store terdiri dari koleksi lebih dari 4,400 asset packages,
beserta 3D models, textures dan materials, sistem particle, musik dan efek suara,
tutorial dan project, scripting package, editor extensions dan servis online.
2.4.2.6 Physics Engine
Unity juga memiliki suport built-in untuk PhysX physicsengine (sejak Unity
3.0) dari Nvidia (sebelumnya Ageia) dengan penambahan kemampuan untuk simulasi
real-timecloth pada arbitrary dan skinned meshes, thick ray cast, dan collision layers.
2.5 Android
Permainan komputer (computer game) adalah permainan video yang
dimainkan pada komputer pribadi, dan bukan pada konsol permainan, maupun mesin
ding-dong.Permainan komputer telah berevolusi dari sistem grafis sederhana sampai
menjadi kompleks dan mutakhir.Namun, pasar permainan komputer di Amerika
20
Game komputer dibuat oleh satu atau beberapa pengembang game,
biasanyabersama dengan spesialis lainnya (seperti game artists) dan dipublikasikan
baik secara sendiri atau melalui penerbit pihak ketiga. Mereka kemudian
mendistribusikan pada media fisik seperti DVD dan CD, atau dapat didistribusikan
secara bebas melalui internet, software, atau melalui jasa pengiriman online seperti
Direct2Drive dan Steam. Game komputer membutuhkan hardware khusus di
komputer pengguna untuk bermain, seperti generasi spesifik unit pemrosesan grafik
atau koneksi internet untuk bermain online, meskipun persyaratan sistem ini
12
BAB 1 PENDAHULUAN
1.1. Latar Belakang
Kecerdasan buatan merupakan cabang ilmu computer yang bertujuan membuat mesin
menjadi lebih pintar dan dapat melakukan pekerjaan seperti manusia. Kecerdasan
dapat diterapkan dalam membuat game dengan menentukan sejumlah aturan.
Kecerdasan buatan dalam game umumnya digunakan untuk membuat non – player
characters (NPCs) yang bergerak dengan sendirinya didalam game. Selain itu,
kecerdasan buatan juga digunakan untuk menghasilkan solusi dari sistem kepada
pemain game. Jadi tujuan adanya kecerdasan buatan tidak untuk mereplikasi pikiran
dari binatang atau manusia, namun untuk membuat NPCs lebih cerdas dengan
reaksinya sendiri dalam game sesuai dengan lingkungan yang dihadapinya.
Game memiliki banyak variasi bentuk dan diciptakan mulai dari tingkat
kesulitan mudah kompleks dengan tujuan membuat suatu game menjadi lebih seru
untuk dimainkan. Permainan puzzle merupakan salah satu permainan yang
membutuhkan pemikiran yang panjang dalam menentukan langkah selanjutnya yang
akan diambil. Permainan puzzle yang cukup dikenal akhir–akhir ini adalah permainan
puzzle 2048 yang merupakan salah satu permainan game yang dimainkan dengan cara
memberikan masukan berupa arah untuk menggeser kotak-kotak yang muncul
didalamnya. Ketika dua dari kotak yang saling berhimpit berisikan angka yang sama,
maka mereka akan disatukan dan nilainya dijumlahkan. Tujuan utama dari game ini
adalah mendapatkan kotak dengan nilai 2048 sebelum semua grid terisi penuh dan
tidak ada kotak yang dapat disatukan lagi. Permainan puzzle 2048 diciptakan oleh
Gabriel Cirulli untuk iOS dan Android dan cukup banyak beredar.
Permainan puzzle 2048 banyak diminati oleh berbagai kalangan dikarenakan
13