UDKThailand

UDKThai.blogspot.com >>> UDKThai.com เร็วๆนี้ซื้อแล้ว จัดการ host อยู่จ้า

2012-03-20T06:55:00.001-07:00

กลับมาปัดฝุ่นเร็วๆนี้ อาจจะมีการเปลี่ยนรูปแบบใหม่จ่ะ

2012-03-17T00:02:00.001-07:00

Video Tutorial Camera

2012-02-05T23:40:00.000-08:00

Input

Camera Isometric Lock Position

Camera TPS Zoom and smooth

Camera TPS pototype Gears of war

Library Function

2012-01-29T07:52:00.000-08:00

Actor Class

Spawn
เป็นการเชื่อมต่อ class ของ Object ที่ทาง UDK ได้ให้กำหนดไว้เช่น Pawn Camera Controller Navigation พูดง่ายๆ ตัวไหนที่มีตัวตนในเกมโดยมี buffer ไหลผ่านและเป็น class หลักๆ จะสามารถใช้ได้ อย่างอื่นไม่สามารถ จะใช้เชื่อมต่อได้
โดยมี Parameter ดังนี้

native noexport final function coerce Actor

Spawn (
class<Actor> SpawnClass,
optional Actor SpawnOwner,
optional name SpawnTag,
optional Object.Vector SpawnLocation,
optional Object.Rotator SpawnRotation,
optional Actor ActorTemplate,
optional bool bNoCollisionFail
)

Worldinfo Class

BroadCast

Coming Soon

(เสริม) ส่วนประกอบใน Source Code UDK

2012-01-29T07:35:00.001-08:00

โครงสร้างในการเขียน Source code UDK

Class จะเป็น ในส่วนของการควบคุม Function หรือ method หรือแม้แต่ Properties ก็ตาม

Function จะเป็นคำสั่งในส่วนต่างๆ

Properties จะทำให้ variable ที่เราตั้งไว้สามารถ กำหนด ค่าเริ่มต้นใน ที่นี้ได้

ตัวอย่าง

Class โรงเรียนอารามิ Extends ศูนย์กลางการเรียนรู้;

var int ห้องเรียน

function ห้องน้ำ(น้ำ,ไฟฟ้า,จำนวนห้อง)
{
น้ำ = 50 ลิตร;
ไฟฟ้า = 200 watt;
จำนวนห้อง = 10 ห้อง;
}

Class และ Function จะได้ราวๆนี้

ส่วน properties

DefaultProperties
{
ห้องเรียน = 20
}

แสดงว่าโผล่มาเมื่อ class ถูกเรียกหรือดึงเข้าไปร่วมในการทำงาน ดังนั้น ห้องเรียน ที่มีค่าเริ่มต้น

จะมี 20 เราสามารถ เพิ่มได้ภายหลัง ที่เราจะเขียนใน function หรือ + เพิ่มไปใน variable ได้

บทที่ 7.1 การยิงปืนโดย มีลูก กระสุน หรือ projectile เป็นตัวบ่งชี้

2012-01-19T06:13:00.001-08:00

วันนี้ผมจะมา สอนสร้างเกม ครับ โดยเราจะมาเริ่มในบทที่ 7.1 เรื่องการยิง

ก่อนอื่นให้เราสร้าง file มาหนึ่ง file ครับนั่นก็คือ เราจะตั้ง class projectile หรือลูกกระสุน

คราวนี้ ให้เราตั้ง class เลยครับ

class GunnerBProjectile extends UDKProjectile;

Defaultproerties
{

Begin Object Class=DynamicLightEnvironmentComponent Name=MyLightEnvironment
bEnabled=TRUE
End Object
Components.Add(MyLightEnvironment)
begin object class=StaticMeshComponent Name=kason_gunnerB // สามารถเปลี่ยนได้ครับ ไม่ว่าจะเป็น particlesystemcomponent หรือ จะใช้ skeletal ก็ได้
StaticMesh=StaticMesh'WP_BioRifle.Mesh.S_Bio_Blob_01' // รูป model ที่จะเป็น ลูก กระสุน
LightEnvironment=MyLightEnvironment
end object
Components.Add(kason_gunnerB)

}

คราวนี้เรามาเชื่อมต่อกับ อาวุธที่ จะใช้ยิงครับ

เรามาเพิ่ม หนึ่ง function กัน

simulated event vector GetPhysicalFireStartLoc(optional vector AimDir)

{

    local SkeletalMeshComponent compo;

    local SkeletalMeshSocket socket;

    compo = SkeletalMeshComponent(Mesh);

    if (compo != none)

{

        socket = compo.GetSocketByName('MussleFlashSocket');

    }

    if (socket != none)

{

        return compo.GetBoneLocation(socket.BoneName);

}

}

ตัวนี้ ถ้าผมจำไม่ผิด น่าจะเป็น function ที่ช่วยในการบังคับให้ projectile ในการออก หรือพ่น ออกไปใน 

socket ที่ตั้งเอาไว้ ครับ

เปลี่ยนประเภท การยิง WeaponFireTypes(0)= ให้เป็น EWFT_Projectile

แล้วก็เพิ่มอีก 1 properties ก็คือ ข้างล่าง

WeaponProjectiles(0)=class'MyGame.SandboxPaintballProjectile'
OK หลังจากนั้น ก็ลองทดสอบ complie แล้วยิงดู

เดี๋ยวผม จะลง video การเขียนให้นะครับ โดยผ่านทาง Youtube Channel DevoursTV ครับ

2012-01-19T06:11:00.000-08:00

Torn Banner Studios

admin ลาพัก 2 วัน

2012-01-17T04:35:00.000-08:00

เนื่องจาก ช่วยนี้ admin นอนดึกงาน มากไปหน่อย ทำให้ช่วงนี้เพียลๆ

รออีกสัก วัน พฤหัส จะมาลง บทความทำลูก กระสุนแล้ว ลง video ย้อนหลังไป บทแรกๆ ก่อนนะครับ

บทที่ 7 ติด อาวุธ เตรียมยิง!!!!!

2012-01-12T00:46:00.001-08:00

บทที่ 7 จะเป็นการสอน ติดอาวุธให้
ตัวละครไม่ว่าจะเป็น bot หรือ Player
ก็สามารถ ติดได้ตลอดจนแม้กระทั้ง
ตัวละครอะไรๆก็ตาม ในนี้ผมจะติด
การสอน video เข้าไปด้วยและ
สามารถ Download source code
ไปดูได้อีกด้วย

VIDEO Tutorial

Download Source

Download Now

First Project Game

2012-01-05T08:28:00.001-08:00

Mini-Game Demo:
http://www.mediafire.com/?fhn8iehmf78tx98
http://www.mediafire.com/?4ytu6z5rxxrs5t4
http://www.mediafire.com/?0033hblgfl7nd08

Source Code:
http://www.mediafire.com/?ybcznvtkzmjdxld

อธิบาย

StartInfo.uc คือโผล่มาจะเป็น การเริ่มเกมครับ แต่ยังไม่ได้กดอะไรนะครับ ในนี้นี้จะสังเกตุว่าผม

HUDType นี่เป็นการเรียก หรือเชื่อมต่อกับ HUD นะครับ โดยเชื่อต่อกับ Class StartGamePlay
เรามาดูใน StartGamePlay กัน

simulated function PostBeginPlay() {
super.PostBeginPlay();
HudMovie = new class'GFxStartGame';
HudMovie.SetTimingMode(TM_Real);
HudMovie.start();
}

ซึ่ง Method ที่ผมโชว์เป็นตัวเรียก นะครับ

HudMovie = new class'GFxStartGame'; // new class คือการเชื่อมต่อกับ Object นะครับ
HudMovie.SetTimingMode(TM_Real); // ทำงาน method SetTimingMode ใน Class GFxStartGame ซึ่ง
จริงแล้ว SetTimingMode ไม่มี ใน GFxStartGame หรอกครับแต่ GFxStartGame มัน สืบทอดมาอีกที
HudMovie.start(); // เริ่มการทำงานครับ จะเห็นว่า GFxStartGame มี parameter ทำไมไม่ใส่ จริงๆแล้วไม่ต้องใส่ครับ เพราะมันเป็นสิ่งที่บอกว่า จะใส่ก็ได้หรือไม่ใส่ก็ได้ optional ครับ

เรามาดู GFxStartGame กันดีกว่า

(ซัดดีคอนเจน สองเม็ด สมองรั่นป๋อแล้ว)

function StartGamePlay(){
Consolecommand("open Mario?Game=MyGame.TestGame");
}

อ่าสังเกตุบรรทัดนี้ครับ

ไปดู file flash ของผม จะตังเกตุว่า มันได้อ้างถึงชื่อ function นี้แสดงว่า ว่า Btm_play.onress เมื่อทำการ
กดลงไปนั่นเอง เมื่อทำการ กดลงไปให้ทำงานวิ่งมาหาใน UDK ครับแสดงว่าส่งค่าให้ script

มาทำงานใน UDK แล้ว แสดงว่ามันสั่งให้มารันที่ function StartGamePlay นั่นแหละ
เนื่องจาก ใน Object ตัวนี้สามารถใช้ ConsoleCommand ได้อ่า ผมก็ใช้ใน ส่วน command ในส่วนของ

บทที่ 1 ได้เลยนิครับ open เปิด แผนที่ ชื่อว่า mario?Game=Folder.Class info ที่จะต้องการรันนะครับ
ก็จะได้เทคนิคในการเปลี่ยน map ในส่วนของบทที่ 6 ที่ผมได้สอนไปครับ
อ่ะคราวนี้เรามาดูในส่วนของ TestGame

เมื่อมันเรียก Class TestGame แล้วมันจะไปไหนต่อ มะเรามาดูกันตรงที่

var int readyEndgame; ตัวนี้ดีกว่า ผมกำหนดใน Default ไว้ให้มันเป็น 0 นะครับ ให้เราลองเข้า

CreaditEndgame ดูครับ สังเกตุ บรรทัด

function Tick(float Time){
if(TestGame(worldinfo.game).readyEndgame == 1){
HudMovie = new class'GFxEndgame';
HudMovie.SetTimingMode(TM_Real);
HudMovie.start();
}
}
อ่า สังเกตุบรรทัดแดงๆครับ readyEndgame == 1 จึงจะให้เข้าไปทำงาน HudMovie ครับ
สาเหตุ function Tick มันจะทวนทำงานตลอด ครับมันจะคอยเป็นหน้าที่ ดัก buffer ข้อมูลครับ
ไม่เชื่อว่ามันทำงานตลอดให้เลง ประกาศ log มันออกไปแล้วไปดู console log ครับแล้วท่านจะเห็น
เอง

อ่าเรากลับมากันดีกว่า แล้วเราก็ไปต่อกันที่ MyPawn ดีกว่า

เรามาดู ที่ function กล้องก่อนดีกว่า

simulated function bool CalcCamera(float fDeltaTime, out vector out_CamLoc, out rotator out_CamRot, out float out_FOV)
{
out_CamLoc = Location;
out_CamLoc.X = -600;
out_CamLoc.Z = 300;
out_CamRot.roll = 0;
out_CamRot.Pitch = 0;
out_CamRot.Yaw = 0;

if(mem == 0){
mem = 1;
savepoint_cam = out_camLoc;
}

if(out_camLoc.Y >= savepoint_cam.Y){

savepoint_cam.Y = out_camLoc.Y;
}

else

{
out_camLoc.Y = savepoint_cam.Y;
}
return true;
}

เนื่องจาก function นี้ได้รับ buffer ตลอดครับเลยทำให้ทำงานคอยตรวจสอบตลอดครับ

โผล่มาผมก็ lock องศากล้องคงที่เลยครับ

out_CamLoc = Location;
out_CamLoc.X = -600;
out_CamLoc.Z = 300;
out_CamRot.roll = 0;
out_CamRot.Pitch = 0;
out_CamRot.Yaw = 0;

เมื่อผมตั้งค่ากล้องอะไรเรียบร้อยแล้ว คือผมไม่อยากให้กล้องวิ่งกลับ
mem ตัวนี้ผมสร้างขึ้นมาเพื่อจดจำว่า จะให้ savepoint_cam จำค่ากล้องครั้งแรกเมื่อทำการเข้าเกม
if(out_camLoc.Y >= savepoint_cam.Y){ ก็คือ ถ้า ตัวแปลที่ผม savepoint ตัวนี้ทำการวิ่ง ถ้า ตัวแปลของกล้องตัวจริงๆ นี่วิ่งผ่านไปมากกว่า savepoint_cam.Y แนว Y ก็จะทำการ ให้ savepoint_cam.Y เนีย
จำว่า savepoint_cam.Y มีค่าเท่าไหร่ แต่ถ้ามันน้อยกว่า ก็คือ out_camLoc.Y จะมีค่าเท่ากับ savepoint_cam.Y และมันจะไม่ทำให้กล้องวิ่งกลับไปตาม Player ครับ

return true คือการยอมรับว่า เราจะใช้การตั้งค่าตัวนี้ครับ

เรามาดู บรรทัด PostBeginPlay กันต่อดีกว่า

var array<NavigationPoint> MonsterSpawnPoints;

สิ่งแรกถ้าใครเข้า map ผมจะสังเกตุว่าเห้ย มีแอบเปิ้ลด้วย จริงๆแล้วมันชื่อว่า path node ครับไว้คอย
ทำหน้าที่ ที่ว่าหาจุดให้ Bot เกิดครับ

ซึ่ง variable ข้างบนที่ผมตั้ง นั้นผมจะตั้งเป็น array ครับเนื่องจากว่า เพราะ pathnode มันมีแค่ ตัวแปลเดียว
แต่มันมีหลายๆ ตัวอยู่ในตัวแปลเดียว

ผมก็เลย ใช้ Foreach

simulated function postBeginPlay(){
local PathNode PS;
super.PostBeginPlay();
bCanDoubleJump=true;

foreach WorldInfo.AllNavigationPoints(class'PathNode', PS)
{

MonsterSpawnPoints.addItem(PS);

}

}

AllNavigationPoints ก็ึิืคือหา class ที่เป็น NavigationPoints ที่มัน Extend มานั่นก็คือ PathNode ครับ
ยัดเข้าไปในตัวแปล PS ครับซึ่งผมได้สร้างไว้รอแล้ว

โดยการนำ หน้าที่ MonsterSpawnPoints มารับ

มันมี สองวิธีครับ โดยการใช้ i++ แต่ในที่นี้ ผมเลือกใช้ addItem เนื่องจากว่า มันสดวกและง่ายครับ

และมันยังสามารถ เรียงลำดับ array ให้เหมือน การนั่งนับ array ต้นแบบได้อีกด้วย

ข้อเสียคือ มันนับข้ามไม่ได้ครับ จะนับก็คือ 0-อินฟรี ไปเลยครับ

ซึ่งนับมาเก็บไว้ ครับสามารถ ตรวจสอบ โดยการ for i++ ก็ได้ครับโดยการใช้วิธี บทที่ 1.2.1 ครับ

ในที่นี้เราจะประกาศ ในรูปแบบ ของ log สามารถ ย้อนกลับไปดูใน content ใน Editor เลือก Tab scense ครับ

แล้วจะสังเกตุว่า ตรงช่อง Actor ครับ ให้เลื่อนลงมาเลื่อยๆครับ จนกว่าจะเจอ Pathnode ที่ผมสร้างไว้ นั่นแสดงว่า สามารถ กดเข้าไปดูได้ด้วยนะครับ ว่า มันอยู่ ตำแหน่งตรงไหน ครับ
ส่วนถ้าจะสร้างใหม่ให้ท่านทำการ คลิกขวา แล้วเลือก Add actor จะเจอกับ Pathnode เอง

อันนี้ คือ Basic สำหรับการ วางจุด ให้ การ Pawn ครับส่วน

เมื่อได้จุดแล้ว

มาดู Event Tick ครับ

เรามาดูสองตัวอย่างกันดีกว่า

if(bot == 0 && vsize(MonsterSpawnPoints[1].location - location) < 560){
bots = spawn(class'BotController');
bots.pawn = spawn(class'Snake',,,MonsterSpawnPoints[1].location,);
bots.Possess(bots.pawn,false);
bot++;
}

เรามาทำความเข้าใจกับ Vsize กันก่อน vsize เป็นการ กำหนดระยะทาง vector ครับ สามารถ เอามาลบกัน
ทำให้เกิดผล การใกล้การ ไกลได้ ตัวนี้อย่าพึ่งสนใจ เรามาสนใจตรง

bot == 0 นี่คือ bot ตัวที่ 1 ครับ ถ้า bot == 0 แน่นอนว่า ไม่ได้ตั้งค่า ให้มัน มันก็ 0อยู่แล้ว
ดังนั้น จะต้อง vsize(MonsterSpawnPoints[1].location - location) << หมายถึง ระยะทางของ point ที่ monster จะเกิด กับระยะทางที่ Player เดินเข้าไป จะต้อง < น้อยกว่า 560 ถึงจะเข้าไปทำการ

เรียก bot ให้เกิด โดยจะต้องสร้างวิญญาณให้มันก่อน นั่นก็คือ Controller เอามารองรับ
พอได้วิญญาณ มันเสร็จ ให้ทำการ ตั้ง Pawn ในบรรทัด

bots.pawn = spawn(class'Snake',,,MonsterSpawnPoints[1].location,);

สังเกตุ MonsterSpawnPoints[1].location อันนี้ผมกำหนด ตายตัวไว้เลย บอทตัวนี้จะต้องเกิด ใน pathnode array ที่ 1 ครับ ซึ่งใน pathnode array ที่หนึ่งที่โดนยัดมาเนีย จะไม่จำเป็นต้อง มีค่าตรงกับ ใน scene ครับ
เราจะรู้ด้วยการประกาศ log ออกมาแล้วไปเทียบใน Editor อีกที ถ้าเราเลือก ตำแหน่ง ใน scene

ที่ pathnode_1 แต่ array ที่เรายัดมาดันไปอยู่ array ที่ 2-3 ก็มี ดังนั้นควรตรวจสอบก่อนจะเอาลงครับ
bots.Possess(bots.pawn,false); ก็ลองไปเปิดใน BotController ในส่วนนี้จะเป็นการทำงาน ในส่วนให้บอท

ประมาณว่า ให้สิงค์ วิญญาณ ของ bot เข้ากับ ตัว บอทแล้วครับ แล้ว ก็ bot ++ ก็คือ ให้ ตัวแปร bot มีค่า
เท่ากับ 1 ครับนั่นก็หมายความว่า มันจะไป รอที่ ระยะทางของ Vsize อีกแล้ว อ่า

จุดที่สองที่แตกต่างก็คือ

bots.range = 300; // ระยะทาง
bots.pointera = MonsterSpawnPoints[0].location; // จุดกึ่งกลาง ที่จะต้องวิ่งกลับมา

ในที่นี้ผมสร้างไว้ก็คือ วิ่ง ไปข้างหน้า 300 จุดกึ่งกลาง คือ bots.pointera ตัวนี้ผมสร้างขึ้นโดยผมต้อง
การให้บอทรู้ ให้มันวิ่งกลับมา ข้างหลังไม่งั้น วิ่งทะลุหลัก หมื่นเป็นแน่ไม่ยอมวิ่งกลับ อิอิ

โดย จะใช้ทั้งสอง ตัวนี้มาลบกันแล้วมาหา ค่าว่า มันมากกว่า Range ที่กำหนดไว้หรือไม่

อ่าเรามาดูที่ Bot Controller กันดีกว่า

Class BotController extends UDKBot;

var Pawn MoveFollow;
var vector movenext;
var vector pointera;
var float range;

simulated function PostBeginPlay()
{
local PathNode path; // ไม่เกี่ยว
local int i;// ไม่เกี่ยว

}

event Possess(Pawn iP,bool bV){
super.Possess(iP,bV);
Pawn.setMovementPhysics();
if(Pawn == Snake(Pawn)){ // ถ้าเป็น class Snake ให้เข้าไปทำงาน ข้างใน
movenext = Snake(Pawn).Location; // รับค่าพื้นที่ ที่จุด snake อยู่ จะรับแค่ครั้งเดียวเท่านั้น
gotostate('Snake'); // วิ่งไป state ของ Snake
}
if(Pawn == turtle(Pawn)){ // ถ้าเป็น class turtle ถึงจะให้ไปทำงานข้างใน
movenext = turtle(Pawn).Location; // เหมือนข้างบนเลย
Pawn.GroundSpeed = 400; // กำหนดความเร็ว
gotostate('turtle'); // วิ่งไป state ของ turtle
}

if(Pawn == flying(Pawn)){ // ไม่เกี่ยว

//Pawn.bCanJump = true; // ไม่เกี่ยว
//pawn.SetPhysics(PHYS_Falling); // ไม่เกี่ยว

} // ไม่เกี่ยว

}

state Snake{
begin:
movenext.Y -= 20; // ให้วิ่ง ไปทาง ซ้าย ทีละ 20
MoveTo(movenext,,0); // กำหนด function ในการวิ่ง
goto('begin'); // วิ่งไปเลื่อยๆ ก็หมายถึง ให้กลับมา begin ต่อ
}

state turtle{

begin:

movenext.Y = pointera.Y - range; // เอาค่า จุดกึ่งกลาง มาลบ กับระยะทาง ก็จะได้ออกมา นี่ไปด้านซ้าย
MoveTo(movenext,,0); // กำหนดให้ วิ่งโดยเอาค่าข้างบนมาใช้ จะวิ่งให้ถึงจุดก่อนถึงจะทำ งานบรรทัดต่อไปได้
movenext.Y = pointera.Y + range; // เหมือนด้านบน แต่อันนี้ไปด้านขวาแทน
MoveTo(movenext,,0);
goto('begin'); // เริ่ม begin ใหม่อีกรอบ

}

event Tick(float Time){
if(Pawn == flying(Pawn)){ // ตรวจสอบว่า เป็น class Flying หรือเปล่า
if(Pawn.Location.Z <= -50){ // เมื่อ ตัวละคร ตกไปอยู่ ต่ำกว่า -50
Pawn.JumpZ = 900; // ความแรงในการโดด
Pawn.Velocity.Z = 1000; // แรงโน้มถ่วง Z ประมาณว่า ผลัก ขึ้นมา 1000
}
}
}

DefaultProperties{
}

กลับมาที่ Pawn เรามาดู Do jump เป็นขั้นตอนสุดท้ายแล้ว

นั่นก็หมายความว่า กระโดด เหยียบหัว ถึงจะเด้ง

Dojump เป็นค่า Native อยู่แล้วจะไม่เหมือน Bot ซึ่ง bot สามารถ กำหนด แรงโน้มถ่วงได้เลย

แต่ Player จะมีตัว Dojump เจ้าปัญหา คอยดักเวลากระโดดอยู่ ฉะนั้นเราจะต้องมาแก้ไขใน DoJump

อีกรอบ

function bool DoJump( bool bUpdating )
{
// This extra jump allows a jumping or dodging pawn to jump again mid-air
// (via thrusters). The pawn must be within +/- DoubleJumpThreshold velocity units of the
// apex of the jump to do this special move.
if(MultiJumpRemaining > 1){
if ( PlayerController(Controller) != None )
PlayerController(Controller).bDoubleJump = true;
DoDoubleJump(bUpdating);
MultiJumpRemaining -= 1;

//*************** ตรงนี้ ผมไปดึงมาจาก UTPawn นั่นเป็นการกระโดด ธรรมดาๆ เฉยๆนะครับ *******//

if ( Physics == PHYS_Spider )
Velocity = JumpZ * Floor;
else if ( Physics == PHYS_Ladder )
Velocity.Z = 0;
else if ( bIsWalking )
Velocity.Z = Default.JumpZ;
else
Velocity.Z = JumpZ;
if (Base != None && !Base.bWorldGeometry && Base.Velocity.Z > 0.f)
{
if ( (WorldInfo.WorldGravityZ != WorldInfo.DefaultGravityZ) && (GetGravityZ() == WorldInfo.WorldGravityZ) )
{
Velocity.Z += Base.Velocity.Z * sqrt(GetGravityZ()/WorldInfo.DefaultGravityZ);
}
else
{
Velocity.Z += Base.Velocity.Z;
}
}
SetPhysics(PHYS_Falling);
bReadyToDoubleJump = true;
return true;
}else{
super.DoJump(bUpdating);
return true;
}

}

เราไปดู class Input

ซึ่งใน Class Input นั้นที่ผมเขียน จะเน้นเป็นการ ตรวจสอบพื้นที่ ในการขยับมากกว่า

คือถ้าวิ่งต่ำกว่าที่กำหนด คือจะวิ่งถอยหลังไม่ได้แล้ว

( นอกเรื่อง ) Books For Unreal Development Kit

2012-01-04T10:35:00.000-08:00

บทที่ 6 Scale Form

2012-01-01T20:24:00.000-08:00

Scale Form เนื่องจาก UDK ได้ลบ UIScense ไปจึงทำให้ผมนั้นสร้าง GUI ของเกมไม่ได้

ก็เลยจำเป็นต้องมาพึ่งพา flash สามารถ

Download ตัวทดลองไปใช้ได้ครับ ที่นี่

Download อ่าเมื่อ Download มาติดตั้งแล้วเรียบร้อย ( สาเหตุทำไมผมถึงไม่ใช้ UDK ทำเนื่องจากว่า UIScense ถูกตัดออกไป ถ้ายังดึงดันที่จะทำ จะใช้เวลานาน และ ดวงที่จะออกมาไม่สวยเลยมีสูง ผมก็จึงตัดปัญหาไป ครับ ) ซึ่งถ้าใครมี CS3 - 5 ก็สามารถ มาทำได้ครับ ซึ่งในที่นี้ผมจะสอนการ ใช้งาน flash เบื้องต้นด้วย เอาละเริ่มมาเริ่มจาก การทำหน้าตา GUI กันก่อนดีกว่าครับ

หลังจากจำเจ ในรูปแบบการนำเสนอเดิมๆผมได้เปลี่ยน รูปแบบใหม่ให้ดูสวยขึ้น

ยังไงก็ช่วยกัน vote ด้วยนะครับ ว่าอ่านเข้าใจหรือไม่

Installing
ก่อนอื่นก็เข้าไปที่ Adobe Extension Manager CS5 กด Install แล้วก็ไปที่ Folder UDK ของเรานะครับ เข้าไปที่ Binaries\GFx\CLIK Tools แล้วจะเห็นไฟล์ Scaleform CLIK ให้กดเลือกแล้วกด ตกลงครับ จากนั้นเมื่อทำเสร็จแล้ว
ให้ทำการเข้า Flash Pro เลยครับ
หลังจากนั้นก็ทำการ กด Edit ตรง Title Bar ครับเมื่อคุณทำการกดแล้ว
ให้คุณ สังเกตุ Category นะครับให้เลือกคำว่า Actionscript แล้วจะสังเกตุมีปุ่มให้เลือก ว่า Language ถ้ามี actionscript 2 ให้เลือก actionscript 2 นะครับ เลือกเลยครับ actionscript 2

หลังจาก ทำการกดแล้ว Folder ในภาพที่ สามแล้ว ก็จะมีให้เลือกอะไรก็ไม่รู้ไม่ต้องสนใจ ตรงเข้าไปหา Folder UDK คุณ เข้าไป Folder Development เข้าที่ Flash ในที่นี้ผมบอกวิธีการใช้ AS2 ผมก็กด AS2 ครั้งนึง จะมี CLIK โผล่มา เลือกเลยครับ CLIK เลือกแล้วทำการ กด OK แล้วก็ กด OK อีกรอบนึง เพื่อเป็นการยืนยันครับ หลังจากนั้น ไปที่ Title Bar อีกรอบ เลือกคำว่า Window แล้วไปที่
Other Panel ครับ เลือกคำว่า Scaleform Launcher ครับกด มันลงไป

นี่คือตัวทดสอบนะครับ
ก็จะได้หน้าตาแบบนี้มา กด + ครับให้จังเกตุตรง Player Exe กด + บรรทัดนั้นครับยังไม่ต้องไปทำอะไรมันมากครับ คราวนี้กลับมาที่ Folder UDK ครับ เลือก Binaries\GFx แล้วจะสังเกตุว่าจะมีไฟล์ที่ชื่อว่า FxMediaPlayer แล้วมันจะมีให้ตั้งชื่อ Player name ตั้งเลยครับ แล้วกด Ok
แล้ว ก็ กด OK ซ้ำไปอีกรอบครับ
ก็จะได้มา แค่นี้แหล่ะครับ กด็จะได้
ตัวทดสอบมาแล้วเรามาต่อ การทำงานต่อดีกว่า

Working

เรามาเริ่มทำการสร้างก่อนดีกว่า

ในที่นี้ผมจะเลือกใช้ Actionscript 2.0 นะครับกดมันเข้าไป หลังจากนั้น
ทำการ สร้างเลยครับ

หลังจากนั้นให้ทำการ Edit เพื่อเลือกเพื่อนที่ครับ
สำหรับผมแล้วจะเลือก มาทดลอง ประมาณ 1024 x 720
ก่อนนะครับเพื่อเราเอามาทดสอบ

หลังจากนั้นผมจะทำการ เลือก Tool bar ให้เลือก

Icon ดังต่อไปนี้รูปนี้ครับ เมื่อ ผมเลือกแล้ว ผมก็เลือกสีดำ นะครับแล้วก็ ลากคลุมเพื่อนที่ทั้งหมด
เพื่อสร้างเป็น BG ครับตรงนี้คุณสามารถ คิดเองทำเองได้นะครับ
หลังจากนั้นให้ คุณลาก พื้นหลังที่คุณตกแต่งไว้ไปยัง Library ครับ

หลังจากนั้นนะครับ ผมก็ทำการลากดึง ตกแต่งอะไรบ้างแล้ว
ผมก็ เอามาวางไว้นะครับ เวลาลากวาง มันจะมาให้เลือก ตั้งชื่อ
แล้วจะมี select item ให้เลือก คุณเลือกเป็น Movie clip นะครับ
เพราะว่า มันจะง่ายต่อการเขียน เดี๋ยวส่วน button เดี๋ยวเรามาเริ่ม
กันต่อ อีกครับนะครับ หลังจากนั้น ผมว่า เราควรจะมาสร้าง mouse กันก่อนนะครับ

เนื่องจากเป็นส่วนประกอบที่ ขาดไม่ได้เลยทีเดียว

มาเรามาสร้างกัน ให้เราใช้ไอรูปเหลี่ยมๆ ที่ผม แนะนำให้สร้างเป็นพื้นในขั้นต้นนะครับ จริงๆมันชื่อ Rectangle Tool นะครับ Key ลัด กด R เพื่อ
ความเร็วในการใช้งาน

อ่ามาเลือกกันดีกว่า กดมันลงไปคับ แล้วสร้างนอก กรอบนะครับอย่า

สร้างในพื้นที่ BG ของเรานะครับ เลือกมันไปวางเป็น movie clip ก่อนนะครับ หรือใครจะสร้าง mouse เองเลือกเอาเลยครับ

สำหรับผมก็สร้างเป็นรุปแบบนี้อิอิ

Mouse Cursor

อ่า จะได้รูปแบบ ผมก็เอาไปทำเป็น movie clip แล้วหลังจากทำแล้วให้กดมัน
เป็นกรอบ สีน้ำเงินแบบนี้ครับ เพื่อเราจะไปกด F9 จะได้ เขียน actionscript กัน

ให้คุณเอา Code นี้ไปใส่ นะครับ
แต่เดี่ยวก่อน mouse คุณควรจะสร้าง Layer ไว้ใน Layer ท้ายๆนะครับ เพระว่า
Layer ต้นๆ จะทำให้ Button นั้นทับ Cursor จนทำให้ มองไม่เห็น Mouse นั่นเอง
หลังจากนี้เรามาใส่ code กัน

onClipEvent(enterFrame)
{
_x=_root._xmouse;
_y=_root._ymouse;
}

มันจะหมายถึง การให้ mouse ควบคุม แกน X Y หน้าจอได้โดย parameter ให้เฟรมแต่ละเฟรม เข้าไปทำงานเปลี่ยน ครับ

หลังจากนั้นให้ทำการ Save ครับ Save เลยครับ Save ไว้ใน UDKGame > Flash > ตั้งชื่อ folder คุณแล้วเอาเข้าไปไว้เลยครับ

หลังจากนั้น กลับไปอ่านข้างบนครับ ซึ่งผมทำการบอกว่า นั่นมันคือ ตัวทดสอบ อ่า ทำการเปิดขึ้น
มาแล้วทำการ กดทดสอบครับ

เมื่อทำการ กดแล้วคุณจะได้
เห็นดั่งภาพที่ผมกำลังจะเอาขึ้นแสดงให้คุณดู

เอาแล้ว มันขยับตามแล้ว
ต่อไปเราจะมาสร้าง Button กันดีกว่า

Button

มาเรามาสร้าง button กันเถอะโอ้วจะเที่ยงคืนแล้ว ผมจะใช้ rectangle นะครับในการสร้าง button
ผมก็สร้าง Layer อีกชั้นขึ้นมาครับเพื่อที่จะมาทับ พื้นหลังครับไม่งั้นถ้าไม่สร้างโดนพื้นหลังทับแน่ๆ
หลังจากที่ผมสร้างเสร็จแล้วผมก็กระทำการลากไปวางที่ Library อีกทีครับ แล้วก็ทำการเลือกจาก Movie เป็น Button นะครับ

อ่าเรา หลังจากนั้น ให้เราลบ อันเดิมออกไปก่อนแล้ว เราก็ดึงจาก Library มันครับ ชักมันมาลงมาครับ
แล้ว double click เข้าไปที่ ปุ่มตัวนั้นครับทำการสร้าง Text Layer จัดอะไรให้เรียบร้อยครับ ใน Layer ที่
สองผมแนะนำให้เป็น Text ครับ ใน Tab Timeline คุณจะ KeyFrame จะมีสี่ช่องครับ

Up , Over , Down , Hit ครับ

Up หมายถึง มันยังไม่ได้ทำอะไรเลย ว่างๆครับ
Over หมายถึง เมื่อเอาเมาส์ เข้าไปวางครับ
Down หมายถึง ทำการ กดลงครับ
Hit หมายถึง ปล่อย ครับ

คลิก ขวา ที่ช่องเหล่านั้น

เรามาเริ่มกันต่อ จะสังเกตุ สามตัวที่
ผมวงกลมมันไว้ ลองไปเล่นกันดูครับ
ซึ่งผมจะอธิบายเกิ่นไว้ๆ
Insert Frame เป็นการสร้าง frame โดย
การกระเถิบ ครับ
Insert Keyframe เป็นการเลือกช่องที่
ยังไม่มี Frame เลยให้เป็น Frame ว่างๆครับส่วน เจ้า Scene 1 และ Play นั้น
เป็นการเข้า ฉากครับ เมื่อถ้าเรา
กด Double click ที่ฉากไหน เราก็จะ
สามารถ เข้าไปกระทำ Scene ข้างใน
นั้นได้อีกครับ ต้องลองว่ามันต่างกันตรงไหน ให้คุณลอง ไปเล่นกันดู

หลังจากนั้นให้เรา มาตกแต่งแต่ละ
Keyframe ดูครับ อ่าเมื่อเราตกแต่งเสร็จแล้ว มาดูของผมดีกว่า ผมจะทำการ Test Run

นี่ผลงานของผม อ่า มาถึงตานี้
ให้คุณมาสร้าง Actionscript กันอีกรอบ
แต่คราวนี้ เราจะมาสร้างหน้า root
หรือว่า แรกสุดว่างั้น
หลังจากนั้นก็สร้าง Layer ขึ้นมาใหม่
ให้ตั้งชื่อว่า Actionscript ครับสาเหตุ
เพื่อที่เราจะได้ไม่ งง ไงครับ

ผมลืมบอก ให้ทำการตั้งชื่อปุ่มด้วยนะครับ วิธีมีดังนี้ ให้ทำการคลิกที่ปุ่ม ให้

ให้คลิกที่ปุ่ม ที่เราสร้างขึ้นครับแล้วทำการ ตั้งชื่อ ใน input box ที่ผมวง
แดงๆไว้ครับ ผมจะตั้งชื่อว่า PlayGameMath นะครับ
จากนั้นให้ใส่ code ไว้ใน Layer Actionscript นะครับ

import flash.external.ExternalInterface;
import gfx.controls.Button;
import gfx.motion.Tween;
_global.gfxExtension = true;
import mx.utils.Delegate;

PlayGameMath.onPress = function(){
ExternalInterface.call("StartGamePlay");
}

// PlayGameMath.onPress เมื่อ ปุ่ม ที่ชื่อ PlayGameMath ทำการกด
จะเท่ากับ function เหล่านี้ หมายถึง สร้าง function ย่อยหรือ ทำงานใน
function นั้นเลยก็ได้

// ExternalInterface.call("StartGamePlay"); ตัวนี้จะเป็นการเรียก function ใน class GFX นะครับ

เมื่อทำการ ใส่ code เสร็จแล้ว เวลาเราไปกด Test แล้วกดปุ่ม ก็จะได้แบบนี้ ขึ้นมาครับ หลังจากนี้ ให้ทำการ
Save แล้วทำการ Export ครับ
ไปที่ File > Export > Export movie
หรือเราจะทำการกด key ลัดโดย
กด ctrl+alt+shift+s พร้อมกันครับ
แล้วก็เลือก folder ไว้ที่เดียวกับ file เรานะครับ นั่นก็ต้องอยู่ใน UDKGame > Flash ด้วยนะครับ หลังจากนี้ให้ทำการเข้า Editor ครับ เพื่อเราจะ ได้ Import File ที่เข้าสร้างขึ้นไปใช้กับ unrealscript ครับ
อ่าก่อนอื่นให้ทำการเข้า Editor ก่อนเลยครับ สังเกตุใน Content ครับ
จะมีให้สร้าง My_Collection อยู่ ผม กด + เลยทันทีแล้วทำการตั้งชื่อ ผมจะตั้งชื่อว่า My Flash ครับ

อ่าเมื่อได้แล้วทำการ click ขวา

แล้วก็ทำการเลือกไฟล์ที่อยู่ใน UDKGame > Flash เอาไฟล์ที่คุณ Export มาครับ swf อ่าเมื่อได้แล้ว
ก็จะขึ้นรูปแดงๆแบบนั้นครับ ให้เราลากไปวาง My Flash เลยครับ
มันก็จะอยู่ในนั้นหลังจากนั้นให้เรา
คลิกขวา ที่รูป File ที่เรา Import มาหลังจากนั้นกด คำว่า Save คัรบ
ซึ่งมันจะอยู่ล่างๆครับจากนั้นก็ออก
Editor เลยครับ มาขึ้น Unrealscript กัน

Unrealscript

คราวนี้ เราจะมาสร้าง Class เพื่มอีก สอง Class ครับ MyHUD และ MyGFxHUD

เรามาดูกันเลยครับ Class แรก เขียนอะไรบ้างเน้อ

class MyHUD extends UDKHUD;

Defaultproperties
{
}

//=======================================================

class MyGFxHUD extends GFxMoviePlayer;

Defaultproperties
{
}

//=======================================================

หลังจากทำการสร้างแล้วนะครับให้สร้างเพิ่มครับ ตั้งชื่อว่า MainMenuGame.uc นะครับ

class MainMenuGame extends GameInfo;

Defaultproperties
{
HUDType=class' MyHUD'
}

แล้วก็เปลี่ยน ตัวรัน จาก shotcut บทแรกๆที่ผมสอนไปนะครับให้เปลี่ยน

Game=MyGame.TestGame

เป็น

Game=MyGame.MainMenuGame

แทนนะครับ

อ่ะเรามาดู Class MyHUD

//================================================

class MyHUD extends UDKHUD;

var MyGFxHUD GFxMovieGame;

singular event Destroyed() {
if ( GFxMovieGame != none) {
GFxMovieGame.Close(true);
GFxMovieGame = none;
}
}

simulated function PostBeginPlay() {
super.PostBeginPlay();
GFxMovieGame = new class' MyGFxHUD'; // ทำการเชื่อม class
GFxMovieGame.SetTimingMode(TM_Real); // ตั้ง mode ของ เวลา
GFxMovieGame.start(); // เริ่มการทำงาน จาก class MyGFxHUD
}

Defaultproperties
{
}
//================================================

class MyGFxHUD extends GFxMoviePlayer;

function bool Start(optional bool StartPaused = false)
{
Super.Start(); // เริ่ม ให้ MovieInfo ได้แสดงหรือ Show นั้นเอง
Advance(0); // เวลาที่กำหนด

return true; // true = ให้แสดง false = ไม่ให้แสดง หรือ ยังไม่ให้สั่ง start จนกว่าจะ true
}

function StartGamePlay(){
ConsoleCommand("Open 2?Game=MyGame.TestGame"); // เป็นการสั่งการทำงาน ใจรูปแบบ ConsoleCommand สามารถ พิมพ์ในเกมได้ด้วย กด tab จะมี box ขึ้นมาให้พิมพ์ command
}

Defaultproperties
{
MovieInfo=SwfMovie'Game1.CLIK_tutorial_skinned'; // ทำการเลือกไฟล์มาโชว์ swfmovie จาก Content
bDisplayWithHudOff=TRUE
TimingMode=TM_Real
bPauseGameWhileActive=TRUE // หยุดเกมจนกว่า จะเป็น false
bCaptureInput=true // ให้ Input ยังทำงานได้ต่อ false = ไม่ยอมให้ Input ทำงาน
}

หลังจากเสร็จ ทุกขั้นตอนแล้วลองรันดูครับ อิอิ

จากนั้นมันก็จะเข้าเกม เราเอาแค่นี้ก่อนละกันเดี๋ยว ชื่ออะไร นี่จะขอต่อหลังจาก เกมแรกนะครับ

แต่ต่อเป็นบทอื่นแทนครับ

Happy New Year 2555

2012-01-01T00:33:00.000-08:00

สวัสดีครับ ปีนี้ก็ปี 2555 ซึ่งทาง UDKThai ได้ก่อตั้งมา 6 วันแล้ว เราจะพัฒนาให้ดียิ่งขึ้นบทความ
เราก็จะพยายาม ปรับปรุงอยู่ตลอดเวลา ให้มีความน่าอ่านและอ่านง่ายขึ้น

ขอให้ทุกคน สนุกกับการเขียนเกมนะครับ

บทที่ 5.1 PlayerController : Camera

2011-12-31T22:19:00.001-08:00

วันนี้ผมจะมาสอนเรื่องการสลับ กล้องนะครับและการ ZOOM เข้า ZOOM ออก

ก่อนอื่นคุณต้องเข้าไปดูบทที่ 5 อ่าจำได้ไหมที่ผมสอนว่าสามารถตั้งค่าอะไรพวกนั้นได้

จะมีบาง function ที่เราสามารถนำเข้ามาใช้ได้จริง

ก่อนอื่นก็เลือกปุ่มที่จะเป็นการทำให้ zoom in zoom out นะครับแล้วก็ สังเกตุบรรทัด GBA_

ครับจะเห็นว่า Command= ข้างหลังนี่ นี่มันคือคำสั่งครับ ผมจะเลือก

PrevWeapon และ NextWeapon ซึ่งจะเป็น MouseScrollUp และ MouseScrollDown อ่าาา

ผมรู้ได้ไงครับผมก็เอาเจ้า GBA_ ที่มี command ข้างบนมาดูบรรทัดข้างข้างล่างครับ

บรรทัดข้าง บนจำพวก GBA

Name="GBA_PrevWeapon",Command="PrevWeapon"

บรรทัดข้างล่าง จำพวก Mouse Keyboard

Name="MouseScrollUp",Command="GBA_PrevWeapon" นี่ไงครับ

อ่าเมื่อเราได้มาแล้วก็เข้าไปที่ MyController เลยครับ

อ่าเมื่อเข้า MyController เสร็จแล้วให้ทำการเขียน

exec function PrevWeapon(){
worldinfo.game.broadcast(self,"Prev");
}

exec function NextWeapon (){
worldinfo.game.broadcast(self,"Next");
}

แล้วลองเลื่อนขึ้นเลื่อนลงดู ครับจะเห็นว่า มี ตัวหนังสือสีขาวๆ Prev กับ Next มาด้วย
นั่นก็หมายว่าคุณทำถูกต้องแล้วดังนั้นเราจะมาเริ่มใช้คำสั่ง Camera ให้มัน Zoom เข้า Zoom ออกกัน

อ่ะให้เราไปที่ MyPawn อีกรอบแล้วยัด function นี้เข้าไป

simulated function name GetDefaultCameraMode( PlayerController RequestedBy )
{
return 'FreeCam_Default';
}

หลังจากนั้นกลับมาที่ MyController กลับมาที่ function PrevWeapon()

แล้วเพิ่ม PlayerCamera.FreeCamDistance -= 64; ลงไป Next ก็เช่นกันแต่เปลี่ยนจาก

-= มาเป็น += นะครับ สาเหตุก็เพราะว่า ผมจะทำการให้กล้องมัน มีระยะ เลื่อนเข้าเลื่อนออกครับ

อ่ะใส่แล้วลองรันดู

อ่า Zoom เข้า Zoom ออกได้แล้วววว แต่ทำไม Camera หมุน Unit ไม่หมุน นั่นก็เป็นเพราะ Free Camera ไม่ได้สั่งให้ Pawn นั้นหมุน ตาม camera เพราะ เป็น Free ครับมันจะทำให้ทำเกมได้หลากหลายแนว
ซึ่งวิธีการปรับก็ง่ายๆ เลยครับ

function updaterotation( float time){
local rotator new_rot;
super.updaterotation(time);
new_rot = rotation;
pawn.setrotation(new_rot);
}

แล้วลองรันดู ปรากฏว่า ขึ้นลง หัวทำไมดิ่งลงอ่าาาาา เรามีวิธีแก้ดังนี้ เพราะว่า pitch มันไปตามกล้อง
ดังนั้นเราต้อง fix ให้มันเป็น 0 เอออ ทำไงน้ออออ ก็งี้เลย

function updaterotation( float time){
local rotator new_rot;
super.updaterotation(time);
new_rot = rotation;
new_rot.pitch = 0;
pawn.setrotation(new_rot);
}

แค่นี้แหล่ะ ก็ได้แล้ว

Q: ทำไมถึงต้อง new_rot ด้วยล่ะ เราสั่ง rotation.pitch เลยไม่ได้หรอ
A: ไม่ได้ครับเพราะว่า rotation เป็นค่า Cont จึงทำการดัดแปลงหรือเปลี่ยนแปลงไม่ได้ รับได้อย่างเดียว

สำหรับวันนี้ ผมขอ เอาไว้แค่นี้ก่อนเดี๋ยว เอาบทความ สร้าง menu กันเลยดีกว่าเพราะ
ยังไงเดี๋ยวเราได้เจอ ไอพวกนี้หนักแน่ หลังเกมแรก นี่แหละ เร็วๆนี้พบกับ ความโหด มันส์
และ ระบบ ทำเกมได้แหวกแนวแน่นอน

CalcCamera ใช้คู่กันไม่ได้ ไม่งั้นมันจะไม่ทำการ ZOOM

Example Video Camera

Link to page

บทที่ 5.2 ControlBot

2011-12-31T04:52:00.000-08:00

วันนี้ผมจะมาสอนส่วนต่างๆ ใน UDKBot นะครับ ผมก็จะสอนให้ Bot วิ่งตาม
เมื่อ Bot เห็นเราแล้วจะทำการวิ่งตาม หรือการทำให้บอทวิ่งนะครับ

ก่อนอื่นเข้า BotController เลยครับ

การให้ Bot ทำการมองเห็น ผู้เล่น
ก่อนอื่นผมก็สร้าง

Event SeePlayer(Pawn Player){
`log(Player);
}

แล้วทำการลองรันดู โดยที่ผมจะไปยืนตรงหน้า bot นะครับ

มันบอกแล้ว MyPawn_0 หมายถึง Class ผู้เล่น คนที่ 0 นะครับ

อ่ะเราลอง ให้ Bot ทำการ หันหน้ามาหาเราดีกว่าลองดู ครับ
ลบ `log(Player); ออกใส่ Focus = Player; ลงไปแทน แล้วลองรันดูครับ อ่าว มันหันหน้าตาาามม เราด้วยย

ทีนี้จะเป็นการสั่งบอทให้เดิมตามนะครับ

มีอยู่ สองคำสั่ง

MoveTo : การสิ่งบอทวิ่งไปตามที่เรากำหนดไว้
MoveToWard : การสั่งบอทให้วิ่งตามเร็ว หรือตาม Location ของ Pawn ที่เรากำหนด

มะเรามาลองกัน

เรายังอยู่ที่ BotController

ให้เราสร้าง Variable มาตัวนึงเอาไว้ ตรงหัวเลยครับ

Var Pawn MoveFollow;
และสร้าง
State Follow{
}

คราวนี้เรามาเพิ่ม การทำงาน ใน Event SeePlayer นะครับ
MoveFollow = Player;
เพิ่มตัวนี้เข้าไป แล้ว กระทำการ วิ่งไปหา state ที่ผมตั้งไว้
ก็พิมพ์เข้าไปอีก
Gotostate('Follow');

หลังจากนั้น ให้คุณไปเพิ่มคำสั่งข้างใน state Follow

begin:
MoveToWard(MoveFollow,MoveFollow,20);
goto('begin');

//----------------------------------------------------------------------------

var Pawn MoveFollow;

event Possess(Pawn iP,bool bV){
super.Possess(iP,bV);
Pawn.setMovementPhysics();
}

Event SeePlayer(Pawn Player){
Focus = Player;
MoveFollow = Player;
Gotostate('Follow');
}

state Follow{
begin:
MoveToWard(MoveFollow,MoveFollow,20);
goto('begin');
}

//-------------------------------------------------------------------------

เรามาทำความเข้าใจนะครับว่า
ทำไมผมจึงต้องสร้าง Variable MoveFollow มาสาเหตุเลยก็เป็นเพราะว่า variable Player มันข้ามไม่ได้
นั่นเอง แต่มีวิธีลัด ที่จะไม่ต้องสร้าง MoveFollow นั่นก็คือ

MoveToWard(Pawn(Focus), Pawn(Focus) ,20);
ก็จะทำให้ ไม่จำเป็นต้องสร้าง MoveFollow นั่นเอง

เรามาดูการทำงานและหน้าที่ Parameter กันดีกว่า

MoveToward(Actor NewTarget, optional Actor ViewFocus, optional float DestinationOffset, optional bool bUseStrafing, optional bool bShouldWalk = (Pawn != None) ? Pawn.bIsWalking : false);

1: Actor เป็นเป้าหมายที่กำหนดให้วิ่งตาม
2: การ Focus หรือการหันของ Bot เนื่องจากถ้า Focus ข้างบนอย่างเดียวมันจะต้องรอให้วิ่งเสร็จ จึงจะหัน จึงต้องใช้ Unit ที่เราจะให้วิ่งตามด้วย นั่นเอง
3: ระยะทางปายทาง ตัวนี้หมายถึงว่า ระยะห่างในการตามนั่นเอง

เรามาต่อ MoveTo

MoveTo ก็จะคล้ายๆ

คราวนี้ให้เอา คำสั่ง ทั้งหมดของ MoveToWard ข้างต้นออกไปก่อนเพื่อจะได้รู้การทำงาน

เอาล่ะ คราวนี้ ตั้ง state ชื่อว่า Move_To

auto state Move_TO{

begin:
MoveTo(vect(25,90,0),,0);
MoveTo(vect(25,0,0),,0);
goto('begin');
}

แล้วลองรันดู

จะเห็นได้ว่ามันวิ่งไปวิ่งมา Parameter ที่เปลี่ยนไป จาก MoveToWard จะมีแค่ Parameter ตัวที่ 1
เท่านั้น เปลี่ยนจาก Actor เป็น Vector ซึ่งตัวนี้จะคอยกำหนดระยะทาง เป็น Vector เราสามารถ กำหนดเองได้

บทที่ 5 Keyboard Setting

2011-12-31T03:46:00.000-08:00

ผมจะมาสอนการใช้งาน Config ก่อนยังจำได้ไหมบทที่ 1 ที่ผมบอกส่วนประกอบ ว่า
เจ้า Config ไว้ผมจะสอน นั่นแหละครับวันนี้ ได้ใช้กันแล้ว ดังนั้น เข้าไปที่ Config
เรามาดูดีกว่า ว่ามีอะไรกันบ้าง

ก่อนอื่นก็เข้าไปดูที่ Config > DefaultInput

เมื่อเข้าเสร็จ หลายคนอาจจะงงง มันคืออะไรกันเนีย มันก็คือการ ตั้งค่าการควบคุม
หลังจากนั้น ให้เลื่อนลงมาเลื่อยๆจะเห็น มีคำว่า GBA_ นะครับแถวนั้นคือ function ควบคุมภายในเกม

หลังจาก GBA_ แล้ว

;-----------------------------------------------------------------------------------------
; Game Keyboard/Mouse Bindings
;-----------------------------------------------------------------------------------------

หลังจาก บรรทัดล่าภาษา อังกฤษนี้จะเป็น ตัวที่เชื่อมต่อกับ Keyboard ครับเราสามารถ ตั้งค่าเปลี่ยนแปลงค่าได้ เราสามารถ ปรับเปลี่ยนค่าได้ครับ

บทที่ 4.2 Take Damage ( กระทำการโจมตี ศัตรู )

2011-12-30T09:30:00.000-08:00

การ Take Damage หรือการกระทำ Damage ผมจะมาต่อจาก บทที่ 4.1 นะครับ

Class MyPawn

ในที่นี้ผมจะใช้ การ Touch นะครับ
เรามาเริ่มกัน เริ่มจากการเข้าไปดูที่ Properties นะครับ bBlockActors=false นะครับ
แล้วก็เอา Code ข้างล่างลองไปใส่ ดูครับ

event Touch(Actor Other, PrimitiveComponent OtherComp, Object.Vector HitLocation, Object.Vector HitNormal)
{
Other.TakeDamage( 1, None, Other.location,vect(0,0,0),class'DeathString');
Worldinfo.game.Broadcast(self,string(MyBot(Other).health));
}

อ่ะเสร็จแล้วก็จะได้ออกมาดั่งภาพ ข้างล่างครับ

เมื่อได้ดั่งรูปนี้เรา มาทำความเข้าใจในส่วน ที่ผมได้กระทำการเขียนลงไปดีกว่า

event TakeDamage (int DamageAmount, Controller EventInstigator, Object.Vector HitLocation, Object.Vector Momentum, class<DamageType> DamageType, optional TraceHitInfo HitInfo, optional Actor DamageCauser)

อ่ะเรามาสังเกตุ 5 Parameter แรกเป็น parameter บังคับครับ

1 เลยคือจำนวน Damage ครับ
2 นี้ผมไม่รู้เหมือนกัน แต่ผมตั้งเป็น none เพราะไม่มีความจำเป็น
3 โดนณจุดไหน
4 เมื่อโดนจะเคลื่อนย้ายไป vector เท่าไหร่ ลองใส่ดูครับแล้วจะรู้
5 http://wiki.beyondunreal.com/UE3:DamageType_(UDK) เลือกเอาครับ

6 กับ 7 เอาไว้ตรวจสอบกับ ตัวละคร ที่ก่อให้เกิด Damage ครับ

MyBot(Other).health

ผมว่าหลายคน งง ตรงนี้แน่นอน MyBot คือ Class ที่ผมระบุไว้เพื่อจะเอาไป Convert ครับ
หรือเรียกง่ายๆ Actor to Pawn ว่าซึ่งด้วยการดันแปลง ให้อยู่ในรูปแบบ Pawn ของ class MyBot ครับ เพราะว่า
Actor นั้นไม่มี Variable Health ครับจึงต้องดัดแปลงไปอยู่ในรูปแบบเป้าหมายของ Class Pawn เพื่อที่ผม
จะกำหนดเป้าหมายในการเรียกดูแบบเจาะจงก็จะใช้ Class MyBot นำเลยครับเพราะผมต้องการดู
HP ของ MyBot ครับ

ส่วน การ Bump ก็ไม่แตกต่างกันครับ เดี๋ยวเรามาต่อเรื่องต่อไปกันดีกว่าครับ

สรุป

TakeDamage คือการกระทำที่ก่อให้เกิดความเสียหายแก่ Player หรือ Bot นั่นเองโดย การให้กำเนิด
Player หรือ Bot แต่ละครั้ง ระบบจะทำการ กำหนด เลือดมาให้โดย อัตโนมัติ โดยวิธีที่จะทำให้เลือดเริ่ม
ต้นมีเยอะๆก็ ทำใน Pawn ที่เราจะให้กำเนิด ตั้งใน Properties ให้ ตั้งว่า Health = จำนวนเลือดเลยครับ
อย่างเช่น MyPawn ของผมก็คือกำหนด การ Pawn ของ Player ส่วน MyBot ก็คือการ กำหนดการ Pawn ของ Bot ครับ

บทที่ 4 add character ( เพิ่มตัวละคร )

2011-12-30T03:02:00.001-08:00

ก่อนอื่นก็ ลบ บทที่ 3 ก่อนนะครับ ซึ่ง
ในที่นี้ผมจะ เริ่มใหม่แต่ยังไง Class TestGame และ MyPawn และ MyController ของผมอยู่
ซึ่งจะเปลี่ยนตรง TestGame ของผม ให้เป็น

Class TestGame extends gameinfo;
defaultproperties
{
bRestartLevel=false;
bDelayedStart=false;
PlayerControllerClass=class'MyController'
DefaultPawnClass=class'MyPawn'
}

โล่งๆแบบนี้อีกรอบนึง
ทีนี้ผมจะทำการ สร้าง function ชื่อว่า addbot

function addbot(){
}

ให้คุณไปสร้าง file ข้างนอกอีกตัว ชื่อว่า MyBot แล้วทำการ save เป็น .uc
แล้วก็เข้ามาครับ เข้ามาที่ MyBot แล้วทำการสร้าง Class MyBot

Class MyBot Extends GamePawn;

แล้วก็ทำการ Copy ในส่วนของ DefaultProperties มาครับ

DefaultProperties
{

Begin Object Name=CollisionCylinder
CollisionRadius=+0070.000000
CollisionHeight=+0045.000000
BlockZeroExtent=false
End Object

Begin Object Class=DynamicLightEnvironmentComponent Name=env
bIsCharacterLightEnvironment=TRUE
End Object
Components.Add(env)
LightEnvironment=env

Begin Object Class=SkeletalMeshComponent Name=Robot
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
LightEnvironment=env
AnimSets(0)=AnimSet'CH_AnimHuman.Anims.K_AnimHuman_BaseMale'
AnimTreeTemplate=AnimTree'CH_AnimHuman_Tree.AT_CH_Human'
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
PhysicsAsset=PhysicsAsset'CH_AnimCorrupt.Mesh.SK_CH_Corrupt_Male_Physics'
End Object
Mesh=Robot
Components.Add(Robot)
bBlockActors=false
}

ให้ตัด ControllerClass ออกไปก่อนเพื่อจะมาทดสอบว่าตัวละครที่เรา add มามันออกมาหรือไม่

Class MyBot Extends GamePawn;
DefaultProperties
{
Begin Object Name=CollisionCylinder
CollisionRadius=+0070.000000
CollisionHeight=+0045.000000
BlockZeroExtent=false
End Object
Begin Object Class=DynamicLightEnvironmentComponent Name=env
bIsCharacterLightEnvironment=TRUE
End Object
Components.Add(env)
LightEnvironment=env
Begin Object Class=SkeletalMeshComponent Name=Robot
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
LightEnvironment=env
AnimSets(0)=AnimSet'CH_AnimHuman.Anims.K_AnimHuman_BaseMale'
AnimTreeTemplate=AnimTree'CH_AnimHuman_Tree.AT_CH_Human'
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
PhysicsAsset=PhysicsAsset'CH_AnimCorrupt.Mesh.SK_CH_Corrupt_Male_Physics'
End Object
Mesh=Robot
Components.Add(Robot)
bBlockActors=false
}

ดังนั้นกลับมาที่ file TestGame ครับแล้วเพิ่มใน function addbot() ให้เพิ่มข้างในนะครับ เพิ่มลงไป

Spawn(class'MyBot',,,vect(0,0,260),);

ก็จะได้

Class TestGame extends gameinfo;
function addbot(){
Spawn(class'MyBot',,,vect(0,0,260),);
}
defaultproperties
{
bRestartLevel=false;
bDelayedStart=false;
PlayerControllerClass=class'MyController'
DefaultPawnClass=class'MyPawn'
}

แล้วลองรันดู

อั่นแนะมันยังไม่ออก ให้ใช้ auto state ก็ได้ในการ เรียก function นี้หรือว่าจะใช้

event PostBeginPlay(){
super.PostBeginPlay();
addbot(); // เรียก function addbot ทำงาน
}

Class TestGame extends gameinfo;
event PostBeginPlay(){
super.PostBeginPlay();
addbot();
}
function addbot(){
Spawn(class'MyBot',,,vect(0,0,260),);
}
defaultproperties
{
bRestartLevel=false;
bDelayedStart=false;
PlayerControllerClass=class'MyController'
DefaultPawnClass=class'MyPawn'
}

หลังจากนั้นจะได้ภาพที่เห็น

ผมจะให้มันลอยยังงี้ก่อนนะครับเพราะว่าเอาไว้เช็คว่ามีการ ใส่การควบคุม หรือ Control รึยังนะครับ

มาเรามาต่อกันที่ UDKBot นะครับ
สร้าง file มาอีกหนึ่ง file ชื่อว่า BotController ครับ แล้วกระทำการ save เป็น .uc แล้วก็เข้าไปใน file ไปแก้
ไข โดยสร้าง Class ชื่อว่า BotController โดยการ Extends เป็น UDKBot ครับ
เมื่อเสร็จแล้ว ให้ทำการ

สร้าง event Possess ครับ event ตัวนี้จะคล้ายๆให้บอทมีการสวมใส่วิญญาณของมันครับ
อ่ะโดยการ สร้างมันเลยครับ parameter ตัวแรกจะเป็น pawn และตัวที่สองจะเป็น bool ครับ
event Possess(Pawn iP, bool bV){
super.Possess(iP,bV);
Pawn.setMovementPhysics();
}

ครับแล้วลองรันเกมดู

นั่นมันตกลงมาแล้วววว

จริงๆเมื่อ Pawn มาแล้วมันมีเลือดด้วยนะ

อันนี้ผมสร้าง auto state ขึ้นมาเขียนคำสั่ง Worldinfo.game.broadcast(self,string(health));
ขึ้นมาโชว์ แต่ผมพิมพ์ใน class MyBot นะ

auto state shouthealt{
begin:
worldinfo.Game.Broadcast(self,string(health));
}

เดี๋ยวเรามาต่อบทที่ 4.2 กันดีกว่า การ Take Damage

สรุป

Spawn เป็น Function ที่ใช้ในการเชื่อมต่อ Class ครับและสามารถใช้คู่กับ Pawn ได้อย่างเข้ากันเลยทีเดียวครับ โดยจะมี parameter ที่คอยกำหนด location และ rotation ครับ

Possess นั้นเป็น function ที่คอยแบบว่าใส่จิตวิญญารให้ เจ้า Controller หรือบอท แม้กระทั้ง Player

setMovementPhysics จะเป็น function ที่กำหนด physic ให้เจ้า bot ของเราครับ เพราะ UDKbot แตกต่างจาก PlayerController ซึ่ง Player หมายถึงเรา Bot หมายถึงสิ่งที่ไม่มีคนควบคุม

bBlockActors คือการให้ต้องการวิ่งผ่าน Collision ที่ตั้งขึ้นหรือไม่ ถ้า true ก็คือ ไม่่ให้นะครับ แต่ถ้า false
คือมันจะไม่ block ก็คือวิ่งผ่านไปได้ครับ

Content และการ กำหนด File ใน script

2011-12-28T23:24:00.001-08:00

ก่อนอื่น ก็ทำการ Run programe UDK Editor ขึ้นมาก่อน // การสร้าง shotcut
มาเรามาเริ่มใน Editor กันก่อนอื่นก็เข้า Editor ก่อน

จะเห็นที่ผม วง แดงๆ เอาไว้นะครับให้เข้าตัว Content มันนะครับ ตัวนั้น มีชื่อว่า Content ครับ

พอเสร็จแล้วจะได้ หน้าตา Content แบบนี้

พอได้แล้วเรามาดูส่วนต่างๆกันดีกว่า

นี้คือการ โชว์ file ต่างๆว่ามีอะไรบ้าง โดยประเภทไฟล์จะเป็นรูปต่าง

สำหรับคนที่เริ่มเขียน สคริป

สังเกตุถ้าได้อ่าน บทความ ที่ผมเขียน script ก่อนหรือว่าพึ่งเคยอ่านก็ตาม
ให้สักเกตุไว้ว่า เวลาเขียน script ประเภทไฟล์นี้จะเป็น class ที่ตายตัวหรือติดมากับ Engine นั่นแหล่ะ
แต่ซึ่งด้วยทั้งนี้ทั้งนั้น วิธีการใส่ class file จะเอา path ขึ้นก่อน แล้วตามด้วยชื่อนะครับ
อย่างเช่น SoundCue'path ตามด้วย .name' staticmesh'path ตามด้วย .name'
มีอีกมากมาย สามารถ ติดตาม blog ผมได้

คราวนี้มาดูต่อครับ

มันคือ Collections ของที่ UDK เตรียม มาให้ในนั้นก็จะมีบางอย่างนะครับแต่ไม่ครบ ปุ่ม all คือเอาทุกอย่างที่มีครับ ถ้าเราไม่เอาใน collections ที่มีมาให้เราจะกด all ก้ได้ จะไปสัมพันธุ์ กับ ภาพ search ด้วยนะ

แสดงถึง Folder ใน Content ครับ // Content ใน บทที่ 1

เราสามารถ เพิ่มได้ ถ้าเราต้องการแบบใช้บ่อยๆ ขี้เกียจเข้าไปหาตัวนี้ช่วยได้
โดย ต้องสร้าง folder โดยการ กดเครื่องหมาย + นะครับ

ตัวนี้จะแสดงถึง การ search หรือการค้นหาจะมี ประเภทให้เลือก นะครับ แต่ AnimTree เราต้องพิมพ์ AnimTree เอาเองนะครับ เลือก เป็น All type เพราะว่ามันไม่มีปุ่มให้ติ๊ก เมื่อค้นหาได้มันจะมาแสดงใน
โชว์ไฟล์ครับ

เมื่อรู้จักกัน หมดแล้ว
วิธีนึงที่ผมใช้ในการ copy ชื่อไฟล์ ไปใส่ใน script ได้รวดเร็ว
เช่น soundcue'ชื่อไฟล์' วิธีนี้
ทำให้ผมทำงานได้รวดเร็ว

เลือกไฟล์ที่ต้องการ copy ชื่อนะครับแล้วทำการ คลิก ขวา ก็คือ Copy Full Name to Clipboard
นี่ก็คือ การ copy ชื่อนะครับ นี่ไงผม copy แล้วมาวางใน blog ผมแล้ว ง่ายไหมครับ SkeletalMesh'CH_IronGuard_Male.Mesh.SK_CH_IronGuard_MaleA'

จากนั้นผมก็ไปทดลองใส่ class ที่ผมเตรียมเอาไว้

บทที่ 2

UDK PhysX

2011-12-27T19:04:00.000-08:00

พูดถึงเรื่อง PhysX คงขาดไม่ได้เลยเจ้า Nvidia

PhysX คือการประมวลผลทำให้ การเคลื่อนไหว ทุกสิ่งที่อย่างที่ PhysX พึงกระทำได้จะทำให้

การเคลื่อนไหวนั้นๆ ขยับได้สมจริง มากขึ้น โดยในที่นี้คงรู้ๆกันอยู่ว่า เจ้า PhysX ทำงานผลเป็น

ยังไง แต่ใน UDK หลายคนยังไม่ได้เห็นของจริงอ่าเรามาดู Clip กันดีกว่าว่า อันไหนบ้างคือ

PhysX ครับ

มันเป็น Technology ที่OK ครับผมบอกได้คำเดียวว่า มันทำให้เกมดูมีชีวิตชีวา มากขึ้นครับ

UDK Requirement System

2011-12-27T18:55:00.000-08:00

ในที่นี้เรามาเข้าใจกันก่อนว่า
UDK มันต้องการ ระบบอะไรบ้าง

Minimum:

Windows XP SP3 or Windows Vista
2.0+ GHz processor
2 GB system RAM
SM3-compatible video card
3 GB Free hard drive space

ที่ขึ้นอยู่นี่นะครับ เป็นระบบ ขั้นต้น คือต้องการ XP หรือ Vista หรือ 7 ก็ได้ครับ

โดย CPU 1 core 2 process ก็ pentium 4 หรือ ต่ำกว่านั้น ก็ได้

โดย Ram อย่างมาก 2 GB

spec ที่ขายในไทยแนะนำ

(ถูกที่สุด และสำหรับคนที่ยังไม่มีคอม)

Celeron G530______________________1520
ECS H61H2-M2_____________________1520
Kingston DDR3 1333 4 GB_____________670
HDD 500 GB_______________________2500
Case + PSU________________________700

6910
+ DVD-RW 500

ขอบคุณ คุณ SolunaZero เป็นคนจัด spec ให้

ส่วนเจ้า Dx11 ความจริงถ้าไม่จำเป็นอย่าพึ่งไปเล่นมันมากครับ เพราะ 1 คือถ้าจะใช้ขั้นสูงๆ ราคา hardware ก็ต้องสูงตาม

Tessellation อะไรพวกนี้ถ้าคุณไม่พร้อมอย่าเล่นแต่ถ้าไม่เล่น Tessellation ก็ได้ครับเพราะองค์ประกอบ Dx11 แสงอะไร

จะดีกว่า DX9 ครับ โดยรวมผมก็ว่ามันดีนะ

Coming Soon ราคาขั้นสูง

บทที่ 3.1 SoundCue

2011-12-27T01:46:00.000-08:00

Sound Cue

หรือ

การเล่นเสียง

ในที่นี้ผมจะมาสอนการเขียน script ในการเล่นเสียงนะครับ

วันนี้เราจะมาเล่นเสียงกันนะครับ
โดยที่เรา

ก่อนอื่นก็มาเริ่มเขียนกันเลยดีกว่าเพื่อเป็นการไม่เสียเวลา เรามาทำความเข้าใจกับเสียงก่อนดีกว่า
เราจะมาต่อ ยอด code จาก บทที่ 2,3 กัน

คราวนี้เปิดตัว Editor ขึ้นมามาทำการเลือก Sound Cue กันผมก็จะหยิบเสียงมาหนึ่งตัว

เมื่อเลือกได้แล้ว ก็จะทำการสร้าง code กันเลยจะต่อยอดจากบทที่ 3 นะครับ

บทที่สามนี่ ผมจะพูดถึงเรื่องการ win อะไรพวกนี้ใช่ไหมครับ งั้นเราลองมาสร้างเสียงแห่งชัยชนะกัน

ดีกว่า เอาล่ะมาเริ่มกัน เรามาดู code เก่าๆกันก่อนดีกว่า

Class TestGame extends gameinfo;

var string win;

event postbeginplay(){
super.postbeginplay();
SetTimer(5,false,nameOf(Ending));
}

function Ending(){
EndGame(none,"Lost");
}

function bool CheckModifiedEndGame(PlayerReplicationInfo Winner, string Reason){
if(Reason == "Lost"){
return false;
}
return true;
}

function PerformEndGameHandling()
{
//super.PerformEndGameHandling();
RestartGame();
}

function string GetNextMap(){
if(win == "winner"){
return "2.udk";
}
}

defaultproperties
{
win = "winners"
bRestartLevel=false;
bDelayedStart=false;
PlayerControllerClass=class'MyController'
DefaultPawnClass=class'MyPawn'
}

อ่่าทีนี้ ผมจะมาลองใส่ code ข้างใน function Ending นะครับ
มาลองกันก่อนอื่นเราต้องนำเข้าเสียงขึ้นมาก่อนทำยังไงล่ะ ผมมีสองทางเลือก

ตัวอย่างคือ

Var soundcue sound_a;

แล้วไปตั้ง defaulproperties
ว่า

// เลือก File ใน Editor มาใช้งาน
sound_a=soundcue'file ที่เลือก'

แล้วก็ไปกำหนดใน function Ending
PlaySound(sound_a);

//--------------------------------------------------------

วิธีที่สอง

กำหนด

// เลือก File ใน Editor มาใช้งาน
PlaySound(soundcue'file ที่เลือก');

//-------------------------------------------------------

ของผมจะใช้แบบวิธีที่สองนะครับ

function Ending(){
PlaySound(SoundCue'A_Music_RomNecris01.MusicSegments.A_Music_RomNecris01_Victory01Cue');
EndGame(none,"Lost");
}

แล้วมาลองรันดู
ตอนชนะก็จะได้เสียงออกมา

สรุป

PlaySound = function ที่ทำงานด้านเสียง

บทที่ 4.1 function Bump หรือ Touch

2011-12-26T06:53:00.001-08:00

เรามาดูความแตกต่างระหว่าง

Touch กับ Bump

เดี๋ยวขอเวลาเขียน unreal script แปบนึง
ที่ผมเคยใช้แต่ยังไม่ได้หา ความจริงแต่อย่างใด

คือ Touch เนียเราจะต้องเข้าไปใน Collision แต่ไม่ได้หมายความว่า เราจะต้องปิดหรือยกเลิก Coillsion
สำหรับ Actor นะครับ ( Actor ในที่นี้คือ ตัวละครนั่นแหล่ะครับ ) ฉะนั้น การที่จะใช้ Touch ได้จะต้องทำคู่กับ bBlockActors=false ซึ่งถ้าเป็น true จะไม่สามารถ เดิน ผ่าน Collision ไม่ได้อยู่ดี ฉะนั้นตัวนี้แหล่ะที่ทำให้ ผม งงอยู่นานส่วน การ bump ก็การวิ่งพุ่งไปชน โดยมาการเคลื่อนไหวชน Collision จะทำให้
bump เกิดการทำงานเกิดขึ้น

ก่อนอื่นเรามาเริ่มกันที่ Class MyPawn ก่อนครับ เรามาทำความเข้าใจกันก่อน
การ Bump หรือ การ Touch ต้องมี Collision เราจะต้องสร้าง สิ่งนี้ขึ้นมาโดยเราสามารถ กำหนดใน
DefaultProperties ได้ครับ

Begin Object Name=CollisionCylinder
CollisionRadius=+0034.000000 // ระรอบๆ เป็นวงกลม
CollisionHeight=+0047.000000 // ความสูง
End Object

โดยชื่อเริ่มต้น ก็คือ CollisionCylinder เปลี่ยนแปลงไม่ได้ครับ ถ้าเปลี่ยน มันไม่รู้จักเลย ในที่นี้ผมจะใช้
Collision แบบ Cylinder นะครับ

ทำไมถึงต้องประกาศ ทั้งๆที่ค่าเริ่มต้นมันก็มี Collision อยู่แล้ว คำตอบคือเจ้า Collision เนียถ้าเราไม่ประกาศ เวลามันจะตั้งเป็นค่าเริ่มต้นให้เวลาใส่ model ลักษณะเล็กๆใหญ่ๆ Model มันจะไม่เกาะพื้นมันจะลอยแบบนี้

จะได้ดั่งภาพที่เห็น ว่ามันลอยจริงๆ
ดังนั้นเราควรจะ ตั้ง Collision ให้มัน
เอาล่ะเรามาตั้ง Touch กันเถอะ
ก่อนอื่นก็ ใส่ collision ที่ผมให้ข้างบนกันก่อนดีกว่าครับ
เพิ่ม bBlockActors=false ใน defaultproperties ครับ

จากนั้น ก็มาลอง

event Touch(Actor Other, PrimitiveComponent OtherComp, Vector HitLocation, Vector HitNormal)
{
`log("test");

}

วางใน Class MyPawn ที่ผมสร้างขึ้นมา
แล้วไปลองรันดูว่า log มันขึ้น คำว่า test หรือเปล่า
ถ้าขึ้นคุณมาถูกทางแล้ว

ที่นี้เรามาดู Parameter ตัวที่หนึ่งจะหมายถึง ตัวละครที่เราวิ่งผ่าน
ส่วนตัวที่สองผมยังไม่เคยใช้มันจริงๆจังๆ เลยไม่อยากอธิบาย
ตัวที่สาม วิ่งผ่านที่จุดไหน ตัวที่ สี่คือ จุดมตราฐาน มันก็คือว่า เราวิ่งผ่าน Collision ที่เป็นวงกลม
เมื่อเราวิ่งผ่านไปตัดจุดไหน แบบเมื่อเข้า Collision เมื่อไหร่ ณ ตอนนั้น มันจะแสดงให้เห็นว่า
เราเข้า ไป touch ในจุด sin cos นั้นจะทำการ แสดง vector ออกมาว่า เราได้เข้า ณ ที่จุด vector นั่นๆ
นั่งเอง ( ว่างๆ จะหาตัวอย่างมาให้ )

เรามาดูในส่วน bump กันก่อนดีกว่า

event bump(Actor Other, PrimitiveComponent OtherComp, Vector HitLocation){
`log("test");
}

ก็จะเหมือน ข้างบนเลยครับ parameter แต่จะไม่มี parameter ที่ 4 เพียงตัวเดียว
ดังนั้น

คราวนี้ก็ถึงตาคุณ ประยุคใช้แล้วล่ะครับ

อันนี้ ตัวอย่าง Touch

อันนี้ผมตั้ง Radius ไว้ที่ 70 ครับ มันเลย แสดงออกผลมาก่อน
จะสังเกตุได้จาก scriptlog นะครับเพราะว่าผมไม่ได้พิมพ์ Test แต่ผม log ในค่าของ hitNormal นะครับ

ในที่นี้สามารถ ทำเกมเช่นแนว Mario ได้ และอื่นๆ

สรุป

Touch คือการเข้าไปอยู่ใน Collision ครับ
Bump คือเมื่อเกิดการชนเกิดขึ้น

บทที่ 3 Game Start & Game Over

2011-12-25T04:09:00.001-08:00

สำหรับการเขียน Unrealscript ชุดนี้ Request Knowledge
ให้เข้าไปอ่าน บทที่ 2 ก่อนนะครับ

เรามาดู Function ที่จะใช้กันดีกว่า

EndGame คือการจบเกมครับ เป็น function ที่ทำให้ Game เวลานั้นๆ หยุดเดิน หรือ พรอต เกมเอาไว้ครับ
โดยที่ function นี้สามารถ แก้ไขได้ โดยที่เราจะใช้การ simulated ก่อน หรือว่าจะเป็น function ไปเลยก็ได้
แล้วการ super เพื่อสืบทอด function ข้างบนมาอีกที โดย function นี้จะอยู่ ใน Class GameInfo เท่านั้น

รูปตัวอย่าง ผมกระโดด พอ เวลา ครบมันก็จะหยุดเลยทันที โดยที่ผมตั้งเวลาไว้ 3 วินาที

GetNextMap จะมีวิธีการใช้ ก็คือ เอาค่า return ไปเป็นการเปลี่ยน ย้าย map ต่อไป อย่างเช่น
เราสร้างมา 2 map. map ที่ 1 คือ 1.udk map ที่ 2 คือ 2.udk
แล้วเราลองมาใช้ function นี้ดู โดย function นี้จะอยู่ ใน Class GameInfo เท่านั้น
โดยเราโผล่มาจะต้องอยู่ใน map ที่ 1.udk จึงจะเห็นผลว่า function นี้ ย้ายไป map อื่นจริงๆ

ตัวอย่างเช่น

function String GetNextMap(){
return "2.udk";
}

CheckModifiedEndGame เป็น Function ที่ใช้คู่กับ EndGame อีกทีโดยจะใช้เชื่อม กับ GetNextMap ทำให้
เหมือนว่าเราชนะ นั่นเอง เพราะ function Winner จริงๆ มันไม่มี เลยต้องใช้แบบนี้แทนตัวนี้จะเป็นการ
ตรวจสอบก่อน จะ EndGame จริงๆ ครับจะตรวจสอบ เป็น Boolean ครับ โดย return false ก็คือจบจริงๆ
ส่วน return true ก็คือ ยังไม่จบเกม
เมื่อ function ข้างบน check แล้ว endGame แล้วแต่ตัวที่จะทำงานต่อหลังจากนี้คือ
PerformEndGameHandling ครับจะเป็นตัวที่เราสามารถเขียนต่อว่าจะทำยังไงต่อ
เช่นจะใช้การ RestartGame(); เป็นต้นโดย RestartGame(); จะเข้าไปอ่านใน function GetNextMap ครับ
จะสังเกตุได้ว่า เมื่อ function Restart ตัวนี้ทำงานแล้วเราไม่ใช่ function GetNextMap มันจะกลับมาอยู่
ใน Map เดิม ซึงเราคุณสามารถ ต่อยอดเป็นอะไรก็ได้แล้วแต่จินตนาการ คุณแล้ว
มาดูตัวอย่างกัน

function bool CheckModifiedEndGame(PlayerReplicationInfo Winner, string Reason)

ส่วน function EndGame

function EndGame(PlayerReplicationInfo Winner, string Reason)

สังเกตุว่า Parameter จะเหมือนกันดังนั้นเมื่อกำหนดให้ EndGame(none,"ค่าที่จะใช้ว่าแพ้")

เข้าไปทำการเขียน CheckModifiedEndGame ขึ้นมาใหม่ ใน CheckModifiedEndGame

เช่น

function bool CheckModifiedEndGame(PlayerReplicationInfo Winner, string Reason){

 if(Reason == "Lost"){

                `log("Test"); // แล้วลอง ดูที่ Log เอง

  return false;

}

 return true;

}

event postbeginplay(){ super.postbeginplay(); SetTimer(3,false,nameOf(Ending)); // ตัว countDown ครับ }

function Ending(){ EndGame(none,"Lost"); }

เมื่อทำการ run แล้วจะเห็นใน Log Console จะเป็น Test อยู่ดังนั้นก็แสดงว่า parameter กำหนด

string มีค่าเป็น Lost ถูกต้องนั่นหมายความว่า End จริงๆ

แล้วเราจะเขียน อย่างไรให้ชนะ หรือว่าทำเป็นด่านต่อไป

ผมจะกำหนดโดย var ละกัน

var string win;

function bool CheckModifiedEndGame(PlayerReplicationInfo Winner, string Reason){

 if(Reason == "Lost"){

                `log("Test"); // แล้วลอง ดูที่ Log เอง

  return false;

}

 return true;

}

event postbeginplay(){ super.postbeginplay(); SetTimer(3,false,nameOf(Ending)); }

แล้วใน Defaultproperties เพิ่มไปว่า

win = "winner"

แล้วลองรันดูครับจะเห็นว่า มัน เปลี่ยนแผนที่จริงๆ

แล้วลองเปลี่ยนเป็นแบบนี้ดู Win = "Lose"

อ่าวแผนที่ไม่เปลี่ยน นั่นก็ถูกต้องแล้วครับ

อันนี้ผมยกตัวอย่างให้ หลังจากนั้นก็ขึ้นอยู่ที่คุณจะเอาไปใช้

สรุป
EndGame คือการจบเกมโดย จะส่งต่อไปให้ CheckModifiedEndGame
CheckModifiedEndGame คือการ เช็คว่า ทำอะไรบ้างเราสามารถตั้งเงื่อนไขข้างในได้
PerformEndGameHandling คือการทำให้เกิดการ EndGame โดยจริงๆเป็น function สุดท้ายที่ทำงาน
RestartGame คือการ ไปสอบถามข้อมูลที่มีอยู่ใน GetNextMap เมื่อได้จะทำการ Restart แล้วเริ่ม map ใหม่
GetNextMap คือการส่งค่า map โดยการ return ค่าเป็น String

บทที่ 2 Gameinfo & Pawn & Controller

2011-12-24T05:19:00.001-08:00

เรามาเริ่ม บทที่สองกันดีกว่า
จะขึ้นอีกวันนึงละ

ผมจะมาเริ่มจาก class เดิมที่ผมเคยสร้างไว้นะครับ
นั่นคือ TestGame

เรามาทวนความจำ โดย บทที่ 1.2 กันก่อนดีกว่า
บทที่ 1.2

หลังจากคุณไปทวนความจำเสร็จเรียบร้อย
มาเรามาเริ่มกัน

ก่อนอื่น ผมจะลบ auto state ออกไป เหลือแค่ class กับ Default แบบนี้

Class TestGame Extends Gameinfo;
DefaultProperties{
}

ผมก็จะสร้างอีก สอง class ไว้เผื่อก่อน
สร้างไฟล์ใน folder เดียวกับ TestGame นะจะได้ไม่เกิดปัญหา

ผมจะสร้าง file ที่ชื่อว่า MyController และ MyPawn
สร้าง Class ตามชื่อไฟล์

Class MyPawn Extends GamePawn;

DefaultProperties{
}
//--------------------------------------------------
Class MyController Extends PlayerController;

DefaultProperties{
}

เรามาเริ่มที่ Class TestGame ก่อน
ผมจะเพิ่มตรง DefaultProperties ข้างในผมจะใส่ว่า

PlayerControllerClass=class' MyController'

**************** เจอกับตัวเลย UDK รุ่นใหม่ๆเดี๋ยวนี้ พางง ฮ่าๆๆ ปีกกาเปิด ผิดบรรทัด ทำเอา Default ไม่ทำงานเลยทีเดียว

DefaultProperties{
}

ให้เปลี่ยนเป็นแบบนี้

DefaultProperties
{
}

************************************************************************

ต่อ
หลังจากนั้นก็จะได้

DefaultProperties
{
PlayerControllerClass=class'MyController'
}

ตอนนี้ ได้ทำการเชื่อมกับ class MyController แล้วเรียบร้อย
ให้ใส่เพิ่มต่อไปว่า
ก็จะกลายเป็น

DefaultProperties
{

bRestartLevel = false;
bDelayedStart=false;

PlayerControllerClass=class'MyController'
}

ทำไมถึงต้อง สองตัวนี้

bRestartLevel << เริ่มด่านใหม่หรือไม่ ตอบ false ไม่ต้องอ่ะ จะอยู่ใน map นี้ เพราะถ้าไม่ใส่ยังไงมันก็ฟ้องว่า ด่านใหม่ตูอยู่ไหน!!
bDelayedStart << สั่งให้มี Delay ภายหลังหรือไม่ false ไม่เกิดเลย

หลังจากนั้น ให้เติมอีกตัวนึง

DefaultPawnClass=class'MyPawn'

แล้วทีนี้ Unit ก็จะวิ่งได้ แต่ยังไม่ได้มี Model แต่ Controller รู้แล้วว่า เรามีการ Pawn เกิดขึ้นแล้วฉะนั้นพรุ้งนี้
เช้าผมจะมาต่อการใส่ Model ของ Pawn แล้วก็ตามด้วย Camera หลายๆรูปแบบ ครับ
สำหรับวันนี้ นอนก่อน เดี๋ยว พรุ้งนี้มาแก้ บทความแต่เช้าเลย

มาเรามาต่อกัน

เราจะมาเข้า MyPawn กัน ซึ่ง พิมพ์จะพิมพ์ใน Default ว่า
Begin Object Class=SkeletalMeshComponent Name=Robot

Begin Object Class คือการเริ่มเรียก Class ที่สำเร็จรูปอยู่แล้วมาใช้งาน โดยในนี้จะเป็น
SkeletalMeshComponant ซึ่งเป็น Class ในการดึง Mesh มาใช้งาน แล้วหลังจากนั้นผมตั้งชื่อว่า Robot
เพื่อจะเอาไป add ครับ
SkeletalMesh=SkeletalMesh'หาไฟล์มาใส่'
หลังจากนั้นผมจะทำการ กำหนด SkeletalMesh ให้มันโดย เข้าไปเลือกใน Editor
// เลือก File ใน Editor มาใช้งาน

SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
หลังจากนั้นให้
End object
แล้วก็
Mesh = Robot
Componant.add(Robot)

Begin Object Class=SkeletalMeshComponent Name=Robot
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
End Object
Mesh=Robot ;
Components.Add(Robot);

ก็จะได้ Model ดังภาพ ดังนั้นเวลาวิ่งจะทื่อครับ ฉะนั้นผมยังไม่ได้ใส่ AnimTree หรือ Animset ครับ
เอาละ เราจะรู้ได้ไงว่าเราเอา Model มาจากไหน ก่อนอื่นเข้า Editor ครับ

Begin Object Class=DynamicLightEnvironmentComponent Name=env

bIsCharacterLightEnvironment=TRUE

End Object

ซึ่ง bIsCharacterLightEnvironment ก็คือทำให้ Character ได้รับแสงจากสภาพแวดล้อม

แล้วก็ทำการ add
Components.Add(env)
กับ
LightEnvironment=env
เข้าไป
หลังจากนั้น เพิ่ม LightEnvironment=env ใน object name robot ที่เราสร้างขึ้นไว้แล้ว

===================================================================

Class MyPawn Extends Pawn;

DefaultProperties
{
Begin Object Class=DynamicLightEnvironmentComponent Name=env
bIsCharacterLightEnvironment=TRUE
End Object
Components.Add(env)
LightEnvironment=env

Begin Object Class=SkeletalMeshComponent Name=Robot
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
LightEnvironment=env
End Object
Mesh=Robot;
Components.Add(Robot);
}

====================================================================

ก็จะได้ออกมา ดังรูป

ต่อไปผมจะมา add
การเคลื่อนไหวของ Model ก่อนละกันนะครับ

เรามาหา animSet กันก่อน
ไปที่ Editor อีกครั้ง ของผมจะเลือก ติ๊ก animSet แล้วกด all assets ครับ

หลังจากนั้น ผมจะเลือก K_AnimHuman_BaseMale นะครับ เราสามารถ เข้าไปตรวจดูว่า มี skeletal Mesh
ตัวไหน ใช้งานร่วมกันได้

ถ้ามันขยับเหมือนตัวต้นฉบับได้ก็แสดงว่า ตัวนั้นถูก กระทำโดย ActorX แล้วเรียบร้อยแล้วซึ่งก็หมายความ
ว่า Model นั้นถูกตั้งค่าการเคลื่อนไหวมาแล้วเรียบร้อย แล้วถูกจัดสันส่วนประกอบนั่นเอง

ผมจะเลือกตัวนี้นะครับวิธีก็ใส่ animeset นะครับก็จะเหมือนกับการ ใส่ Mesh แต่ AnimSet จะเป็น array
ให้ใส่แบบนี้

// เลือก File ใน Editor มาใช้งาน
AnimSets(0)=AnimSet'CH_AnimHuman.Anims.K_AnimHuman_BaseMale'

หลังจากนั้นผมจะมาทำการใส่
Physicsasset
เรามาเข้าใจกันก่อนว่า Physicsasset นั่นคือการทำให้ Model มีค่าเป็น physics ที่ทาง UDK จัดสรรนั่นเอง
โดย ในที่นี้ Physics ตัวนี้จะทำงานคู่กับ Ragdoll เมื่อการเกิดทำให้เกิด Ragdoll จะทำให้ Physicsasset ก็จะเริ่มทำงาน

ตัวอย่าง Ragdoll

Ragdoll คือ Physics อย่างหนึ่งทาง Computer ซึ่งจะเป็น physics ที่เคลื่อนไหวไปในทิศทาง การ falling หรือทางแรงโน้นถ่วงโลก

ตัวอย่าง

// เลือก File ใน Editor มาใช้งาน
PhysicsAsset=PhysicsAsset'CH_AnimCorrupt.Mesh.SK_CH_Corrupt_Male_Physics'

วิธีการหาก็เหมือนกับข้างบนเปะ เลยครับ แต่ติ๊กจาก animation sets ให้ติ๊กเป็น All นะครับ
หลังจากได้แล้ว ที่ขาดไม่ได้เลยคือ

AnimTree ซึ่งตัวนี้ ช่วยให้เราไม่ต้องสร้าง script การเคลื่อนไหวในรูปแบบต่างๆ ของ Unit ได้
เช่น การ moveing falling swimming jumping อื่นๆอีก move แกนไหน หันหน้า หันตัว ได้อีกตัว แหงนหน้า
ไปทางไหนได้อีกตัว ตัวนี้ ใน Editor สดวกมากๆ

ฉะนั้นวิธีหาก็เหมือนเดิมครับ แต่ใน Object Type มันไม่มีให้ติ๊ก ให้เราพิมพ์ช่องค้นหา ก็คือ AnimTree
ในที่นี้ผมจะเลือก AT_CH_Human เนื่องจาก เรามาดูกันต้องดูภาพตาม

นั่นก็คือ ใน AT_CH_Human ของ AnimTree เขา set ไว้ให้หมดแล้วผมจึงใช้ตัวนี้แทนครับ
หลังจากนั้น ก็ใส่ AT_CH_Human เหมือนเดิม

ตัวอย่าง

// เลือก File ใน Editor มาใช้งาน
AnimTreeTemplate=AnimTree'CH_AnimHuman_Tree.AT_CH_Human'

มาเรามาลองดู code ทั้งหมดกัน

Class MyPawn Extends Pawn;

DefaultProperties
{
Begin Object Class=DynamicLightEnvironmentComponent Name=env
bIsCharacterLightEnvironment=TRUE
End Object
Components.Add(env)
LightEnvironment=env

Begin Object Class=SkeletalMeshComponent Name=Robot
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
LightEnvironment=env
AnimSets(0)=AnimSet'CH_AnimHuman.Anims.K_AnimHuman_BaseMale'
AnimTreeTemplate=AnimTree'CH_AnimHuman_Tree.AT_CH_Human'
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
PhysicsAsset=PhysicsAsset'CH_AnimCorrupt.Mesh.SK_CH_Corrupt_Male_Physics'
End Object
Mesh=Robot;
Components.Add(Robot);
}

อั่นแน่ะ เคลื่อนไหวได้แล้ว

เดี๋ยวเรามาเล่น เสียงกันเพิ่มเติมและการปรับกล้องใน Class Pawn

มาต่อโดยกล้อง จาก Pawn ครับ

เราจะใช้ function ที่ชื่อว่า Calc Camera

โดยการเขียน simulated function เพื่อแทรกการทำงาน ก่อนหน้านี้
โดย วิธีการเขียน ก็คือ

Class MyPawn Extends GamePawn;
<< แทรกตรงนี้
DefaultProperties
{

Begin Object Class=DynamicLightEnvironmentComponent Name=env
bIsCharacterLightEnvironment=TRUE
End Object
Components.Add(env)
LightEnvironment=env

Begin Object Class=SkeletalMeshComponent Name=Robot
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
LightEnvironment=env
AnimSets(0)=AnimSet'CH_AnimHuman.Anims.K_AnimHuman_BaseMale'
AnimTreeTemplate=AnimTree'CH_AnimHuman_Tree.AT_CH_Human'
SkeletalMesh=SkeletalMesh'CH_LIAM_Cathode.Mesh.SK_CH_LIAM_Cathode'
PhysicsAsset=PhysicsAsset'CH_AnimCorrupt.Mesh.SK_CH_Corrupt_Male_Physics'
End Object
Mesh=Robot;
Components.Add(Robot);

}

ผม ก็สร้าง function ขึ้นมาชื่อว่า

simulated function bool CalcCamera(float Time,out vector loc,out rotator rot,out float fov){

}

function นี้จะเป็นการ ตั้งค่ากล้องเริ่มต้นนะครับ ส่วนใหญ่จะใช้เป็นตัวการที่ใช้ตั้งค่ากล้องเริ่ม
การ Pawn นั่นเองLocation คือพื้นที่นั่นเอง
ส่วนถ้าเราใช้ใน Class Pawn นั้นไม่ต้องประกาศ this หรือ Pawn อีกรอบเลยครับ หรือไม่ต้องประกาศ MyPawn แต่อย่างใด
ให้เราใช้ Location ไปเลยโดด เรามาดูด้าน Parameter กันดีกว่า loc นั้น ผมได้สร้าง เอาไว้เพื่อ
ส่ง ค่า location ของกล้องออกไปทำงานใน class camera นั่นเอง และ rotator ด้วยเช่นกัน
เพราะฉะนั้น เรามาดูตัวอย่างเลยดีกว่า

simulated function bool CalcCamera(float Time,out vector loc,out rotator rot,out float fov){
loc = vect(0,0,200);
return bool;
}

ท่านจะได้เห็นแต่ภาพมืดๆ นั่นก็เพราะว่า loc ผม fix ไว้ตายตัว คือ พื้นที่ แกน X = 0 Y = 0 Z = 200
vect นั่นจะเป็นตัวจะเป็นตัวจำกัดข้างใน vect จะ return ค่าเป็น vector
vector คือ ตำแหน่งของ 3D นั่นเอง โดย vector จะมีแกน XYZ

แล้ว Rotator จะมี 3 ตัวจะคล้ายๆกับ XYZ โดย ดูได้จากรูป จะมี Roll Pitch Yawข

ครับ ดังนั้น ถ้าใครเรียน sin cos จะรู้ดี ส่วนถ้าใครไม่ได้เรียน จะมี ค่า สูงสุด คือ 16000 ต่ำสุดคือ
0 และ ค่ากลับ คือ -16000 ครับ

สามารถ เช็คได้

simulated function bool CalcCamera(float Time,out vector loc,out rotator rot,out float fov){
loc = location;
rot = rotation
`log(rot.pitch);
return true;
}

แล้วลองหมุนหน้าจอดู แล้วไปดูที่ Log ใน command ดูมาอธิบายขยายความนิดนึง

Controll.rotation ก็คือส่วนที่เราบังคับนั้นเอง ส่วนประกอบของ Controll ก็คือ Input เดี๋ยวเรามาเจาะ
ลึกกันอีกทีครับ

วิธี fix ทำให้กล้องเป็น camera แบบ ในเกม Warcraft3

simulated function bool CalcCamera(float Time,out vector loc,out rotator rot,out float fov){
loc = location;
rot = rotation; // Line 5
rot.pitch = -12050;
loc.Z = 500;
return true;
}

ก็จะได้มุมมองแบบ ในรูปออกมา สูงขึ้น ใช้เม้าส์หมุน ซ้ายขวาได้แต่หมุนขึ้นหมุนลงไม่ได้ครับ
เพราะผม fix pitch ไว้แล้วครับ แล้วมุมสูงขึ้นก็มาจาก แกน Z ผม ตั้งค่าไว้ที่ 500 ครับ
ลองเล่นดูละกันครับ

สรุป

CalcCamera : เป็น function ที่กำหนดการเริ่มต้นค่าของ กล้อง player ที่ติดต่อ กับการ pawn ครับ

SkeletalMeshComponent : เป็น class ที่กำหนด SkeletalMesh ครับส่วนใหญ่จะใช้ในการแสดงรูปร่างของ object

DynamicLightEnvironmentComponent : เป็นการกำหนดด้านแสงครับ โดย SkeletalMeshComponent มักจะดึงไปใช้ครับเพื่อให้ shadow อะไรพวกนี้ทั้งหลายแหล่ ที่เรา Render ออกมาได้แสดงผลจริงๆครับ

bRestartLevel : เป็นการกำหนดว่าเราต้องการเริ่มต้นหรือไม่ โดย ถ้า เป็น false คือยังไม่ได้เริ่มต้น ให้เลือก false นะครับ
bDelayedStart : เป็นการกำหนดว่าเราต้องการเกิดเลยหรือไม่ True เกิดเลย false ยังจนกว่าจะคลิก
PlayerControllerClass : เป็นการกำหนด class Controller การเชื่อมต่อ Class PlayerController นั่นเองครับ