{"id":576,"date":"2010-12-18T06:48:57","date_gmt":"2010-12-18T06:48:57","guid":{"rendered":"https:\/\/astrofra.com\/wordpress\/?p=576"},"modified":"2010-12-18T06:48:57","modified_gmt":"2010-12-18T06:48:57","slug":"mgt-project-devlog-4","status":"publish","type":"post","link":"https:\/\/astrofra.com\/wordpress\/index.php\/2010\/12\/18\/mgt-project-devlog-4\/","title":{"rendered":"MGT Project DevLog #4"},"content":{"rendered":"

Game Items<\/h3>\n

There’s no adventure game<\/strong> without powerups, keys<\/strong> and doors<\/strong>. For this prupose, I needed a generic class that handles the basic operations on items :
\n– the item knows when it interacts<\/strong> with the player and calls the proper method\/function.
\n– the item can be picked, destroyed, unlocked<\/strong>, and this state<\/strong> should remain if the player left the room.
\n– the item can increase the vitals\/energy\/shield of the player, or appear in the game inventory<\/strong><\/p>\n

\"\"<\/div>\n

To perform these actions, and any other kind of possible future needs, I wrote a very simple class called ‘GameItem<\/em>‘<\/p>\n


\n\/\/--------------
\nclass GameItem
\n\/\/--------------
\n{<\/code><\/p>\n

item_trigger = 0
\ninside_trigger = false<\/p>\n

enabled = true<\/p>\n

project_script = 0<\/p>\n

tank = 0
\ntank_script = 0<\/p>\n

function OnUpdate(item)
\n{
\nif (!enabled)
\nreturn<\/p>\n

if (tank == 0)
\n{
\ntank = SceneFindItem(ItemGetScene(item), “tank”)
\ntank_script = ItemGetScriptInstanceFromClass(tank, “SteamTank”)
\n}
\nelse
\n{
\n\/\/ Test the player against the trigger
\nif (item_trigger != 0)
\n{
\nif (TriggerTestItem(item_trigger, tank))
\n{
\nif (!inside_trigger)
\n{
\nprint(“GameItem::OnUpdate() tank inside”)
\nItemTaken(item)
\ninside_trigger = true
\n}
\n}
\nelse
\ninside_trigger = false
\n}
\n}
\n}<\/p>\n

function ItemTaken(item)
\n{
\nprint(“GameItem::ItemTaken() – Stub method called.”)
\n}<\/p>\n

function OnSetup(item)
\n{
\nprint(“GameItem::OnSetup(” + ItemGetName(item) + “)”)<\/p>\n

local _item_trigger
\n_item_trigger = ItemGetChild(item, “item_trigger”)
\nif (ObjectIsValid(_item_trigger))
\nitem_trigger = ItemCastToTrigger(_item_trigger)<\/p>\n

project_script = ProjectGetScriptInstance(g_project)
\nenabled = project_script.GetItemStateEnabled(item)<\/p>\n

if (enabled)
\nEnable(item)
\nelse
\nDisable(item)
\n}<\/p>\n

function Enable(item)
\n{
\nprint(“GameItem::Enable(” + ItemGetName(item) + “)”)<\/p>\n

ItemActivateHierarchy(item, true)
\nenabled = true
\nproject_script.SetItemStateEnabled(item, true)
\n}<\/p>\n

function Disable(item)
\n{
\nprint(“GameItem::Disable(” + ItemGetName(item) + “)”)<\/p>\n

ItemActivateHierarchy(item, false)
\nenabled = false
\nproject_script.SetItemStateEnabled(item, false)
\n}
\n}<\/p>\n

Basically, when setup<\/strong>, the class will look for a trigger<\/strong> parented to the main item. Then, during the update loop, the class will test the player against the trigger<\/strong>. If the item is triggered by the player, a stub method ItemTaken()<\/em> is called.<\/p>\n

\"\"<\/div>\n

Based on this generic class, I can derive (or extend<\/strong>) any kind of specific class, and overload<\/strong> the ItemTaken()<\/em> method.<\/p>\n

The class also provide two methods to enable<\/strong> and disable<\/strong> the item and its children. This is very handy when it comes to hide several items and lights. When disabled, the state of the item will be stored by the project<\/strong>, so that the item will know if it is enabled or not in case the player exits then enters the room again. Here, all the state logic is handled by two accessors methods I wrote directly in the project script : SetState()<\/em> and GetState()<\/em><\/p>\n

Here’s an example of a typical ‘power up’ class inherited from the base GameItem<\/em> class. You will note how the ItemTaken()<\/em> class is overloaded in order to perform the proper action : here it increases the shield level of the player.<\/p>\n


\nclass ShieldCellItem extends GameItem
\n{<\/code><\/p>\n

function OnUpdate(item)
\n{
\nbase.OnUpdate(item)
\n}<\/p>\n

function ItemTaken(item)
\n{
\nprint(“ShieldCellItem::ItemTaken()”)
\ntank_script.ShieldUp()
\nDisable(item)
\n}<\/p>\n

function OnSetup(item)
\n{
\nbase.OnSetup(item)
\n}<\/p>\n

}<\/p>\n

 <\/p>\n

The Inventory<\/h3>\n

Some items can be picked and must be kept<\/strong> by the player. In this purpose, they will invoke another class called Inventory<\/em>. At the moment the implementation of this class is really basic. It is more or less a few accessors to handle an array that contains the game items picked by the player.<\/p>\n


\nclass Inventory
\n{
\ninventory = 0<\/code><\/p>\n

constructor()
\n{
\ninventory = []
\n}<\/p>\n

function AddItem(item_name)
\n{
\ninventory.append(item_name)
\n}<\/p>\n

function RemoveItem(item_name)
\n{
\nprint(“Inventory::RemoveItem(” + item_name + “)”)<\/p>\n

local idx, val
\nforeach(idx,val in inventory)
\nif (val == item_name)
\n{
\ninventory.remove(idx)
\nreturn true
\n}<\/p>\n

return false
\n}<\/p>\n

function FindItem(item_name)
\n{
\nlocal i
\nforeach(i in inventory)
\nif (i == item_name)
\nreturn true<\/p>\n

return false
\n}
\n}<\/p>\n

 <\/p>\n

Video Capture<\/h3>\n

The following video shows the player that grabs several items (a powerup and a key), opens a first door, unlock a second door with the key he just grabbed. The key is marked as a X in the inventory, you can see it appear, the disappear when used.<\/p>\n