mirror of
https://github.com/badvision/lawless-legends.git
synced 2024-06-25 09:29:30 +00:00
Ongoing giant function prototype refactor.
This commit is contained in:
Martin Haye
parent
eea4767a51
commit
998d75c1a0
|
|
@ -16,7 +16,7 @@ include "gen_enemies.plh"
|
|||
include "gen_modules.plh"
|
||||
include "combat.plh"
|
||||
|
||||
predef _combat_zoneEncounter
|
||||
predef _combat_zoneEncounter(s_encZone)#1
|
||||
word[] funcTbl = @_combat_zoneEncounter
|
||||
|
||||
// Combat variables that don't need to be saved in game state
|
||||
|
|
@ -25,12 +25,12 @@ byte nEnemiesFighting
|
|||
byte isFleeing
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def canFight(p)
|
||||
def canFight(p)#1
|
||||
return p=>w_health > 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def chooseEnemy(maxDist)
|
||||
def chooseEnemy(maxDist)#1
|
||||
word p
|
||||
byte n
|
||||
|
||||
|
|
@ -44,10 +44,11 @@ def chooseEnemy(maxDist)
|
|||
fin
|
||||
p = p=>p_combatNext
|
||||
loop
|
||||
return NULL
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def playerMelee(pPlayer, pWeapon)
|
||||
def playerMelee(pPlayer, pWeapon)#1
|
||||
word pEnemy, dmg
|
||||
pEnemy = chooseEnemy(5) // max distance 5 feet for melee
|
||||
if !pEnemy; return FALSE; fin
|
||||
|
|
@ -74,7 +75,7 @@ def playerMelee(pPlayer, pWeapon)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def playerShoot(pPlayer, pWeapon)
|
||||
def playerShoot(pPlayer, pWeapon)#1
|
||||
word pEnemy, pSkill, dmg
|
||||
word chance
|
||||
byte roll
|
||||
|
|
@ -103,46 +104,45 @@ def playerShoot(pPlayer, pWeapon)
|
|||
|
||||
// Miss!
|
||||
displayf2("\n%s shoots at %s but misses.\n", pPlayer=>s_name, pEnemy=>s_name)
|
||||
|
||||
else
|
||||
|
||||
// TODO: consider multi-shot weapons
|
||||
dmg = rollDice(pWeapon=>r_projectileDmg)
|
||||
// TODO: Add extra melee damage for skills, strength, etc.
|
||||
// TODO: consider enemy dodge
|
||||
// TODO: consider enemy armor, and armor bonuses
|
||||
pEnemy=>w_health = pEnemy=>w_health - dmg
|
||||
|
||||
buildString(@addToString)
|
||||
printf3("\n%s shoots %s for %d damage.", pPlayer=>s_name, pEnemy=>s_name, dmg)
|
||||
if pEnemy=>w_health <= 0
|
||||
printf1(" %s is killed!", pEnemy=>s_name)
|
||||
nEnemiesFighting = nEnemiesFighting - 1
|
||||
fin
|
||||
puts("\n")
|
||||
displayStr(finishString(0))
|
||||
|
||||
return TRUE
|
||||
return FALSE
|
||||
fin
|
||||
|
||||
// TODO: consider multi-shot weapons
|
||||
dmg = rollDice(pWeapon=>r_projectileDmg)
|
||||
// TODO: Add extra melee damage for skills, strength, etc.
|
||||
// TODO: consider enemy dodge
|
||||
// TODO: consider enemy armor, and armor bonuses
|
||||
pEnemy=>w_health = pEnemy=>w_health - dmg
|
||||
|
||||
buildString(@addToString)
|
||||
printf3("\n%s shoots %s for %d damage.", pPlayer=>s_name, pEnemy=>s_name, dmg)
|
||||
if pEnemy=>w_health <= 0
|
||||
printf1(" %s is killed!", pEnemy=>s_name)
|
||||
nEnemiesFighting = nEnemiesFighting - 1
|
||||
fin
|
||||
puts("\n")
|
||||
displayStr(finishString(0))
|
||||
|
||||
return TRUE
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def playerDodge(pPlayer)
|
||||
def playerDodge(pPlayer)#0
|
||||
displayf1("\n%s dodges.\n", pPlayer=>s_name)
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def chooseWeapon(player)
|
||||
def chooseWeapon(player)#0
|
||||
displayStr("\nTODO: choose weapon\n")
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def combatPause()
|
||||
def combatPause()#0
|
||||
pause(800)
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def displayOpponents()
|
||||
def displayOpponents()#0
|
||||
word p
|
||||
byte count, first
|
||||
byte isPlural
|
||||
|
|
@ -174,14 +174,14 @@ def displayOpponents()
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def displayOption(key, str)
|
||||
def displayOption(key, str)#0
|
||||
buildString(@addToString)
|
||||
printf2("\n (%c)^T033%s ", key, str)
|
||||
rawDisplayStr(finishString(0))
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def playerCombatChoose(pl)
|
||||
def playerCombatChoose(pl)#0
|
||||
word p, pWeapon
|
||||
byte nWeapons, key
|
||||
byte canShoot, canReload, canChange
|
||||
|
|
@ -258,7 +258,7 @@ def playerCombatChoose(pl)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def playerCombatTurn(pl)
|
||||
def playerCombatTurn(pl)#0
|
||||
word pWeapon
|
||||
|
||||
// Get weapon
|
||||
|
|
@ -301,7 +301,7 @@ def playerCombatTurn(pl)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def enemyCombatTurn(pe)
|
||||
def enemyCombatTurn(pe)#1
|
||||
word pl
|
||||
byte roll, dam, needShow
|
||||
|
||||
|
|
@ -337,7 +337,7 @@ def enemyCombatTurn(pe)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def combatInsert(toAdd)
|
||||
def combatInsert(toAdd)#0
|
||||
word p, pPrev
|
||||
|
||||
// Find the proper position based on combat order number (keep largest first in the list)
|
||||
|
|
@ -356,7 +356,7 @@ def combatInsert(toAdd)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def determineCombatOrder()
|
||||
def determineCombatOrder()#0
|
||||
word p, p2
|
||||
|
||||
nPlayersFighting = 0
|
||||
|
|
@ -393,7 +393,7 @@ def determineCombatOrder()
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def makeEnemyGroup(enemyFunc)
|
||||
def makeEnemyGroup(enemyFunc)#1
|
||||
word p, enem, groupSize
|
||||
p = mmgr(HEAP_ALLOC, TYPE_ENEMY_GROUP)
|
||||
enem = enemyFunc()
|
||||
|
|
@ -413,7 +413,7 @@ def makeEnemyGroup(enemyFunc)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def makeRandomGroup(mapCode)
|
||||
def makeRandomGroup(mapCode)#0
|
||||
word enemiesModule
|
||||
word enemyFunc
|
||||
|
||||
|
|
@ -428,7 +428,7 @@ def makeRandomGroup(mapCode)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def collectLoot()
|
||||
def collectLoot()#1
|
||||
word group, enemies, gold
|
||||
|
||||
gold = 0
|
||||
|
|
@ -445,7 +445,7 @@ def collectLoot()
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def startCombat(mapCode)
|
||||
def startCombat(mapCode)#1
|
||||
word p, p2, n, s
|
||||
|
||||
// Setup
|
||||
|
|
@ -499,12 +499,13 @@ def startCombat(mapCode)
|
|||
beep()
|
||||
loop
|
||||
|
||||
return 0 // just to keep compiler happy
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// For cheating in god mode, kill all enemies. This is better than just setting nEnemiesFighting
|
||||
// to zero, because we'll still get loot.
|
||||
def killAllEnemies()
|
||||
def killAllEnemies()#0
|
||||
word pGroup, pEnemy
|
||||
pGroup = global=>p_enemyGroups
|
||||
// For every group...
|
||||
|
|
@ -524,7 +525,7 @@ end
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Returns: zero if fled, non-zero if won
|
||||
def _combat_zoneEncounter(s_encZone)
|
||||
def _combat_zoneEncounter(s_encZone)#1
|
||||
word p, l, answer
|
||||
|
||||
// Show portrait and threat details, find out if player wants to fight (vs. run)
|
||||
|
|
@ -583,6 +584,7 @@ def _combat_zoneEncounter(s_encZone)
|
|||
p = p=>p_combatNext
|
||||
loop
|
||||
loop
|
||||
return 0 // keep compiler happy
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -13,119 +13,117 @@ import gamelib
|
|||
//////////// Shared library routines ////////////
|
||||
// Let's try to keep these predef's in lexical order
|
||||
predef addEncounterZone(code, x, y, dist, chance)#0
|
||||
predef addGold(amount)
|
||||
predef addGold(amount)#1
|
||||
predef addPlayerToParty(playerFuncNum)#0
|
||||
predef addToList(addTo, p)#0
|
||||
predef addToString(str)
|
||||
predef addUnique(pList, p_thing)
|
||||
predef auxMmgr(cmd, param)
|
||||
predef beep()
|
||||
predef benchPlayer()
|
||||
predef brk()
|
||||
predef buildString(pFunc)
|
||||
predef buySell
|
||||
predef calcPlayerArmor
|
||||
predef calcWidth
|
||||
predef callGlobalFunc
|
||||
predef charToUpper
|
||||
predef checkEncounter
|
||||
predef clearEncounterZones
|
||||
predef clearPortrait
|
||||
predef clearWindow
|
||||
predef countArray
|
||||
predef countList
|
||||
predef countListFiltered
|
||||
predef displayChar
|
||||
predef addToString(str)#1
|
||||
predef addUnique(pList, p_thing)#1
|
||||
predef auxMmgr(cmd, param)#1
|
||||
predef beep()#0
|
||||
predef benchPlayer()#0
|
||||
predef brk()#0
|
||||
predef buildString(pFunc)#0
|
||||
predef buySell(storeCode, profitRatio)#0
|
||||
predef calcPlayerArmor(player)#0
|
||||
predef calcWidth(pStr)#1
|
||||
predef callGlobalFunc(moduleNum, arg1, arg2, arg3)#1
|
||||
predef charToUpper(c)#1
|
||||
predef checkEncounter(x, y, force)#0
|
||||
predef clearEncounterZones()#0
|
||||
predef clearPortrait()#0
|
||||
predef clearWindow()#0
|
||||
predef countArray(arr)#1
|
||||
predef countList(p)#1
|
||||
predef countListFiltered(p, offset, filterFunc)#1
|
||||
predef displayChar(chr)#0
|
||||
predef displayf1(fmt, arg1)#0
|
||||
predef displayf2(fmt, arg1, arg2)#0
|
||||
predef displayf3(fmt, arg1, arg2, arg3)#0
|
||||
predef displayStr
|
||||
predef encodeDice
|
||||
predef fatal
|
||||
predef finalWin
|
||||
predef finishString
|
||||
predef displayStr(str)#0
|
||||
predef encodeDice(nDice, dieSize, add)#1
|
||||
predef fatal(msg)#0
|
||||
predef finalWin()#0
|
||||
predef finishString(isPlural)#1
|
||||
predef flipToPage1()#0
|
||||
predef getCharResponse
|
||||
predef getDir()
|
||||
predef getGameFlag
|
||||
predef getCharResponse()#1
|
||||
predef getDir()#1
|
||||
predef getGameFlag(flagName)#1
|
||||
predef getPos(px, py)#0
|
||||
predef getStat(player, statName)
|
||||
predef getStringResponse
|
||||
predef getUpperKey
|
||||
predef getYN
|
||||
predef giveItemToPlayer
|
||||
predef initHeap
|
||||
predef loadFrameImg
|
||||
predef loadMainFrameImg
|
||||
predef makeModifier
|
||||
predef max
|
||||
predef memcpy
|
||||
predef min
|
||||
predef mmgr
|
||||
predef moveWayBackward
|
||||
predef parseDec
|
||||
predef parseDecWithDefault
|
||||
predef partyHasPlayer
|
||||
predef pause
|
||||
predef payGold
|
||||
predef playerHasItem
|
||||
predef getStat(player, statName)#1
|
||||
predef getStringResponse()#1
|
||||
predef getUpperKey()#1
|
||||
predef getYN()#1
|
||||
predef giveItemToPlayer(p_player, itemFuncNum)#0
|
||||
predef initHeap(loadedSize)#0
|
||||
predef loadFrameImg(img)#0
|
||||
predef loadMainFrameImg()#0
|
||||
predef makeModifier(name, value)#1
|
||||
predef max(a, b)#1
|
||||
predef memcpy(pSrc, pDst, len)#0
|
||||
predef min(a, b)#1
|
||||
predef mmgr(cmd, param)#1
|
||||
predef moveWayBackward()#0
|
||||
predef parseDec(str)#1
|
||||
predef parseDecWithDefault(str, default)#1
|
||||
predef partyHasPlayer(playerName)#1
|
||||
predef pause(count)#0
|
||||
predef payGold(amount)#1
|
||||
predef playerHasItem(itemName)#1
|
||||
predef printf1(fmt, arg1)#0
|
||||
predef printf2(fmt, arg1, arg2)#0
|
||||
predef printf3(fmt, arg1, arg2, arg3)#0
|
||||
predef printHex(num)
|
||||
predef printHex(num)#0
|
||||
predef puts(str)#0
|
||||
predef queue_setMap(is3D, num, x, y, dir)#0
|
||||
predef queue_teleport(x, y, dir)#0
|
||||
predef rand16
|
||||
predef randomFromArray
|
||||
predef randomFromListFiltered
|
||||
predef rand16()#1
|
||||
predef randomFromArray(arr)#1
|
||||
predef randomFromListFiltered(p, offset, filterFunc)#1
|
||||
predef rawDisplayf1(fmt, arg1)#0
|
||||
predef rawDisplayf2(fmt, arg1, arg2)#0
|
||||
predef rawDisplayf3(fmt, arg1, arg2, arg3)#0
|
||||
predef rawDisplayStr(str)
|
||||
predef rdkey
|
||||
predef readStr
|
||||
predef reboot
|
||||
predef removeFromList
|
||||
predef removePlayerFromParty
|
||||
predef rightJustifyNum
|
||||
predef rightJustifyStr
|
||||
predef rollDice
|
||||
predef scanForNamedObj
|
||||
predef scriptCombat
|
||||
predef rawDisplayStr(str)#0
|
||||
predef rdkey()#1
|
||||
predef readStr()#1
|
||||
predef removeFromList(pList, toRemove)#0
|
||||
predef removePlayerFromParty(playerName)#0
|
||||
predef rightJustifyNum(num, rightX)#0
|
||||
predef rightJustifyStr(str, rightX)#0
|
||||
predef rollDice(encoded)#1
|
||||
predef scanForNamedObj(p_obj, name)#1
|
||||
predef scriptCombat(mapCode)#1
|
||||
predef scriptDisplayStr(str)#0
|
||||
predef scriptDisplayStrNL(str)#0
|
||||
predef scriptEvent
|
||||
predef scriptSetAvatar
|
||||
predef scriptSwapTile
|
||||
predef setCmd
|
||||
predef setGameFlag
|
||||
predef scriptEvent(event, param)#0
|
||||
predef scriptSetAvatar(avatarTileNum)#0
|
||||
predef scriptSwapTile(fromX, fromY, toX, toY)#0
|
||||
predef setCmd(key, func)#0
|
||||
predef setGameFlag(flagName, val)#0
|
||||
predef setGround(num)#0
|
||||
predef setIntimateMode
|
||||
predef setIntimateMode
|
||||
predef setMap
|
||||
predef setMapWindow
|
||||
predef setBigWindow
|
||||
predef setPlural
|
||||
predef setPortrait
|
||||
predef setIntimateMode(enable)#0
|
||||
predef setMap(is3D, num, x, y, dir)#0
|
||||
predef setMapWindow()#0
|
||||
predef setBigWindow()#0
|
||||
predef setPlural(flg)#0
|
||||
predef setPortrait(portraitNum)#0
|
||||
predef setScriptInfo(mapName, trigTbl, wdt, hgt)#0
|
||||
predef setSky(num)#0
|
||||
predef setStat(player, statName, val)#0
|
||||
predef setWindow
|
||||
predef setWindow(top, bottom, left, right)#0
|
||||
predef setWindow1()#0
|
||||
predef setWindow2()#0
|
||||
predef setWindow3()#0
|
||||
predef showMapName
|
||||
predef showParty
|
||||
predef showMapName(mapName)#0
|
||||
predef showParty()#0
|
||||
predef sprintf1(fmt, arg1)
|
||||
predef sprintf2(fmt, arg1, arg2)
|
||||
predef sprintf3(fmt, arg1, arg2, arg3)
|
||||
predef streqi
|
||||
predef strncpy
|
||||
predef takeItemFromPlayer
|
||||
predef textHome
|
||||
predef streqi(a, b)#1
|
||||
predef strncpy(dst, src, maxlen)#1
|
||||
predef takeItemFromPlayer(p_player, itemName)#0
|
||||
predef textHome()#0
|
||||
predef tossStrings()#0
|
||||
predef unbenchPlayer
|
||||
predef unbenchPlayer()#0
|
||||
|
||||
// This pointer is the root of all heap-tracked (and garbage collected) objects.
|
||||
// See playtype.plh for definitions of all the datastructures and how they interconnect.
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -38,15 +38,18 @@ const INV_ROWS = (BIGWIN_HEIGHT / 9) - 4
|
|||
|
||||
// Exported functions go here. First a predef for each one, then a table with function pointers
|
||||
// in the same order as the constants are defined in the header.
|
||||
predef _doPlayerSheet, _benchPlayer, _unbenchPlayer
|
||||
predef _displayItemStats, _displayItemName
|
||||
predef _doPlayerSheet(player_num)#1
|
||||
predef _benchPlayer()#1
|
||||
predef _unbenchPlayer()#1
|
||||
predef _displayItemStats(pItem1, pItem2)#1
|
||||
predef _displayItemName(pItem)#1
|
||||
word[] funcTbl = @_doPlayerSheet, @_benchPlayer, @_unbenchPlayer
|
||||
word = @_displayItemStats, @_displayItemName
|
||||
|
||||
// Other global variables here
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def itemByNum(player, num)
|
||||
def itemByNum(player, num)#1
|
||||
word item
|
||||
item = player=>p_items
|
||||
while num
|
||||
|
|
@ -58,7 +61,7 @@ end
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Unequip item kind
|
||||
def unequip(player, type, kind)
|
||||
def unequip(player, type, kind)#1
|
||||
word item
|
||||
|
||||
item = player=>p_items
|
||||
|
|
@ -66,17 +69,18 @@ def unequip(player, type, kind)
|
|||
if item->t_type == type
|
||||
if (streqi(item=>s_itemKind, kind) or type == TYPE_WEAPON) and item->b_flags & ITEM_FLAG_EQUIP
|
||||
item->b_flags = item->b_flags & ~ITEM_FLAG_EQUIP
|
||||
return item
|
||||
break
|
||||
fin
|
||||
fin
|
||||
item = item=>p_nextObj
|
||||
loop
|
||||
return item
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Display title of a column at top but below character name. Optionally append a second string,
|
||||
// then leave a little vertical space below before beginning the content of the column.
|
||||
def showColumnTitle(x, title, page, nPages)
|
||||
def showColumnTitle(x, title, page, nPages)#0
|
||||
rawDisplayf2("^V000\n^J^J^L^J^T%D%s", x, title)
|
||||
if nPages > 1
|
||||
rawDisplayf2(" - p.%d/%d", page, nPages)
|
||||
|
|
@ -86,7 +90,7 @@ end
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Display inventory list page. Return number of items on page.
|
||||
def showInventory(player, page, select)
|
||||
def showInventory(player, page, select)#1
|
||||
word item
|
||||
byte s_item, n_item, n_page, totalPages, first
|
||||
|
||||
|
|
@ -125,7 +129,7 @@ def showInventory(player, page, select)
|
|||
end
|
||||
|
||||
// Display skill value
|
||||
def displaySkill(str, val, col)
|
||||
def displaySkill(str, val, col)#0
|
||||
byte[16] mystr
|
||||
|
||||
strncpy(@mystr, str, 15)
|
||||
|
|
@ -138,18 +142,18 @@ def displaySkill(str, val, col)
|
|||
displayf2("%d %s", val, @mystr)
|
||||
end
|
||||
|
||||
def numToPlayer(num)
|
||||
def numToPlayer(num)#1
|
||||
word player
|
||||
player = global=>p_players
|
||||
while num > 0
|
||||
player = player=>p_nextObj
|
||||
if !player; return; fin // Not that many players
|
||||
if !player; break; fin // Not that many players
|
||||
num--
|
||||
loop
|
||||
return player
|
||||
end
|
||||
|
||||
def displayDice(dice)
|
||||
def displayDice(dice)#0
|
||||
byte n, d, p
|
||||
n = (dice >> 12) & $0F
|
||||
d = (dice >> 8) & $0F
|
||||
|
|
@ -161,12 +165,12 @@ def displayDice(dice)
|
|||
fin
|
||||
end
|
||||
|
||||
def vspace()
|
||||
def vspace()#0
|
||||
rawDisplayStr("^J^J^J^J")
|
||||
end
|
||||
|
||||
// Show stats in the right panel
|
||||
def showStats(player)
|
||||
def showStats(player)#0
|
||||
word weapon, dmg
|
||||
|
||||
showColumnTitle(STAT_X, "Stats", 0, 0)
|
||||
|
|
@ -207,7 +211,7 @@ def showStats(player)
|
|||
end
|
||||
|
||||
// Show aquired skills in lower right panel
|
||||
def showSkills(player)
|
||||
def showSkills(player)#0
|
||||
word skill
|
||||
byte col
|
||||
|
||||
|
|
@ -224,7 +228,7 @@ def showSkills(player)
|
|||
loop
|
||||
end
|
||||
|
||||
def clearMenuRect()
|
||||
def clearMenuRect()#0
|
||||
setWindow(BIGWIN_BOTTOM-10, BIGWIN_BOTTOM, BIGWIN_LEFT, BIGWIN_RIGHT)
|
||||
clearWindow()
|
||||
setBigWindow()
|
||||
|
|
@ -232,7 +236,7 @@ def clearMenuRect()
|
|||
end
|
||||
|
||||
// Display menu for selecting inventory items
|
||||
def showInvMenu(totalItems, itemPage, itemsOnPage)
|
||||
def showInvMenu(totalItems, itemPage, itemsOnPage)#0
|
||||
clearMenuRect()
|
||||
if totalItems > 0
|
||||
rawDisplayf1("Item [A-%c], ", itemsOnPage+'A'+1)
|
||||
|
|
@ -251,7 +255,7 @@ def showInvMenu(totalItems, itemPage, itemsOnPage)
|
|||
end
|
||||
|
||||
// Display menu for selecting inventory items
|
||||
def showItemMenu(item)
|
||||
def showItemMenu(item)#0
|
||||
byte type
|
||||
clearMenuRect()
|
||||
type = item->t_type
|
||||
|
|
@ -265,7 +269,7 @@ def showItemMenu(item)
|
|||
end
|
||||
|
||||
// Equip/unequip an item.
|
||||
def doEquip(player, item)
|
||||
def doEquip(player, item)#0
|
||||
if unequip(player, item->t_type, item=>s_itemKind) <> item
|
||||
item->b_flags = item->b_flags | ITEM_FLAG_EQUIP
|
||||
fin
|
||||
|
|
@ -273,7 +277,7 @@ def doEquip(player, item)
|
|||
end
|
||||
|
||||
// Select an item and use it. Returns item if it needs to be processed by outer loop, else NULL
|
||||
def doUse(player, item)
|
||||
def doUse(player, item)#1
|
||||
if item=>p_modifiers and streqi(item=>p_modifiers=>s_name, "health")
|
||||
if player=>w_health < player=>w_maxHealth
|
||||
player=>w_health = min(player=>w_health + item=>p_modifiers=>w_modValue, player=>w_maxHealth)
|
||||
|
|
@ -282,13 +286,13 @@ def doUse(player, item)
|
|||
removeFromList(@player=>p_items, item)
|
||||
fin
|
||||
fin
|
||||
else
|
||||
return item // general 'use' handled by outer engine, because it might involve graphics
|
||||
return NULL
|
||||
fin
|
||||
return item // general 'use' handled by outer engine, because it might involve graphics
|
||||
end
|
||||
|
||||
// Select an item and drop it. Returns TRUE if anything changed
|
||||
def doDestroy(player, item)
|
||||
def doDestroy(player, item)#1
|
||||
clearMenuRect()
|
||||
rawDisplayStr("Destroy ")
|
||||
_displayItemName(item)
|
||||
|
|
@ -302,21 +306,21 @@ def doDestroy(player, item)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def clearInvRect
|
||||
def clearInvRect()#0
|
||||
setWindow(BIGWIN_TOP+9, BIGWIN_BOTTOM-10, BIGWIN_LEFT, INV_RT)
|
||||
clearWindow()
|
||||
setBigWindow()
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def clearMainRect
|
||||
def clearMainRect()#0
|
||||
setWindow(BIGWIN_TOP+9, BIGWIN_BOTTOM-10, BIGWIN_LEFT, BIGWIN_RIGHT)
|
||||
clearWindow()
|
||||
setBigWindow()
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def matchEquipped(player, match)
|
||||
def matchEquipped(player, match)#1
|
||||
word item
|
||||
item = player=>p_items
|
||||
while item
|
||||
|
|
@ -333,7 +337,7 @@ def matchEquipped(player, match)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def displayItems(pItem1, pItem2)
|
||||
def displayItems(pItem1, pItem2)#0
|
||||
clearMainRect()
|
||||
rawDisplayf1("^V000\n^J^J^L^J^T%DInventory", STATS_COL_1)
|
||||
if pItem2
|
||||
|
|
@ -344,7 +348,7 @@ def displayItems(pItem1, pItem2)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def interactWithItem(player, item)
|
||||
def interactWithItem(player, item)#1
|
||||
word comp, quantity
|
||||
byte sel
|
||||
while TRUE
|
||||
|
|
@ -372,18 +376,19 @@ def interactWithItem(player, item)
|
|||
break
|
||||
// Destroy an item
|
||||
is 'D'
|
||||
if doDestroy(player, item); return; fin
|
||||
if doDestroy(player, item); return NULL; fin
|
||||
break
|
||||
is $1B // Esc
|
||||
return NULL
|
||||
otherwise beep
|
||||
wend
|
||||
loop
|
||||
return NULL
|
||||
end
|
||||
|
||||
// Show player sheet and accept command. If using an item (not just for stats gain)
|
||||
// the item is returned; else NULL is returned.
|
||||
def _doPlayerSheet(player_num)
|
||||
def _doPlayerSheet(player_num)#1 // funcTbl functions always have to return a value
|
||||
word player, item
|
||||
byte i_page, totalItems, itemsOnPage, redisplay, sel
|
||||
|
||||
|
|
@ -394,7 +399,7 @@ def _doPlayerSheet(player_num)
|
|||
redisplay = 2
|
||||
repeat
|
||||
player = numToPlayer(player_num)
|
||||
if !player; return; fin // Invalid player
|
||||
if !player; return 0; fin // Invalid player
|
||||
if redisplay >= 2
|
||||
clearWindow()
|
||||
rawDisplayf1("^Y^I %s ^N\n", player=>s_name)
|
||||
|
|
@ -455,7 +460,7 @@ def _doPlayerSheet(player_num)
|
|||
fin
|
||||
break
|
||||
is $1B // Esc
|
||||
return
|
||||
return 0
|
||||
otherwise
|
||||
sel = sel - 'A'
|
||||
if sel >= 0 and sel < itemsOnPage
|
||||
|
|
@ -466,11 +471,12 @@ def _doPlayerSheet(player_num)
|
|||
fin
|
||||
wend
|
||||
until 0
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Display a list of NPCs and allow user to select one.
|
||||
def selectPlayer(players)
|
||||
def selectPlayer(players)#1
|
||||
byte n_item
|
||||
word player
|
||||
|
||||
|
|
@ -510,7 +516,7 @@ end
|
|||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Allow user to select an active player, and put them on the bench
|
||||
def _benchPlayer()
|
||||
def _benchPlayer()#1
|
||||
word player
|
||||
player = selectPlayer(global=>p_players)
|
||||
if player
|
||||
|
|
@ -518,15 +524,16 @@ def _benchPlayer()
|
|||
addToList(@global=>p_benched, player)
|
||||
displayStr("\nDone.")
|
||||
fin
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Allow user to select a benched player, and put them on the bench
|
||||
def _unbenchPlayer()
|
||||
def _unbenchPlayer()#1
|
||||
word player
|
||||
if countList(global=>p_players) == MAX_PARTY
|
||||
displayStr("Party too large.")
|
||||
return
|
||||
return 0
|
||||
fin
|
||||
player = selectPlayer(global=>p_benched)
|
||||
if player
|
||||
|
|
@ -534,15 +541,16 @@ def _unbenchPlayer()
|
|||
addToList(@global=>p_players, player)
|
||||
displayStr("\nDone.")
|
||||
fin
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def tabTo(cursorX)
|
||||
def tabTo(cursorX)#0
|
||||
rawDisplayf1("^T%D", cursorX)
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def formatDice(encoded)
|
||||
def formatDice(encoded)#0
|
||||
byte nDice, dieSize, add
|
||||
nDice = encoded >> 12
|
||||
dieSize = (encoded >> 8) & $F
|
||||
|
|
@ -552,17 +560,17 @@ def formatDice(encoded)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def formatNum(num)
|
||||
def formatNum(num)#0
|
||||
rawDisplayf1("%d", num)
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def formatStr(str)
|
||||
def formatStr(str)#0
|
||||
rawDisplayStr(str)
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def formatEquipped(num)
|
||||
def formatEquipped(num)#0
|
||||
if num == 1
|
||||
rawDisplayStr("Y")
|
||||
else
|
||||
|
|
@ -571,7 +579,7 @@ def formatEquipped(num)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def formatAttack(code)
|
||||
def formatAttack(code)#0
|
||||
if !code; return; fin
|
||||
if code == 1
|
||||
rawDisplayStr("single")
|
||||
|
|
@ -583,38 +591,35 @@ def formatAttack(code)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def byteField(pItem, field)
|
||||
def byteField(pItem, field)#1
|
||||
if pItem
|
||||
return ^(pItem + field)
|
||||
else
|
||||
return 0
|
||||
fin
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def equippedField(pItem, field)
|
||||
def equippedField(pItem, field)#1
|
||||
if pItem
|
||||
if ^(pItem + field) & ITEM_FLAG_EQUIP
|
||||
return 1
|
||||
else
|
||||
return 2
|
||||
fin
|
||||
else
|
||||
return 0
|
||||
fin
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def wordField(pItem, field)
|
||||
def wordField(pItem, field)#1
|
||||
if pItem
|
||||
return *(pItem + field)
|
||||
else
|
||||
return 0
|
||||
fin
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def displayTwoCol(fieldName, pItem1, pItem2, field, fieldFunc, formatFunc)
|
||||
def displayTwoCol(fieldName, pItem1, pItem2, field, fieldFunc, formatFunc)#0
|
||||
word val1, val2
|
||||
val1 = fieldFunc(pItem1, field)
|
||||
val2 = fieldFunc(pItem2, field)
|
||||
|
|
@ -626,7 +631,7 @@ def displayTwoCol(fieldName, pItem1, pItem2, field, fieldFunc, formatFunc)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def displayWeaponStats(pItem1, pItem2)
|
||||
def displayWeaponStats(pItem1, pItem2)#0
|
||||
displayTwoCol("Equip'd", pItem1, pItem2, b_flags, @equippedField, @formatEquipped)
|
||||
displayTwoCol("Uses", pItem1, pItem2, b_maxUses, @byteField, @formatNum)
|
||||
displayTwoCol("Ammo", pItem1, pItem2, s_ammoKind, @wordField, @formatStr)
|
||||
|
|
@ -640,19 +645,19 @@ def displayWeaponStats(pItem1, pItem2)
|
|||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def displayArmorStats(pItem1, pItem2)
|
||||
def displayArmorStats(pItem1, pItem2)#0
|
||||
displayTwoCol("Equip'd", pItem1, pItem2, b_flags, @equippedField, @formatEquipped)
|
||||
displayTwoCol("Uses", pItem1, pItem2, b_maxUses, @byteField, @formatNum)
|
||||
displayTwoCol("Protec", pItem1, pItem2, b_armorValue, @byteField, @formatNum)
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def displayStuffStats(pItem1, pItem2)
|
||||
def displayStuffStats(pItem1, pItem2)#0
|
||||
// Nothing special
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
def _displayItemStats(pItem1, pItem2)
|
||||
def _displayItemStats(pItem1, pItem2)#1
|
||||
word pMod1, pMod2
|
||||
|
||||
// First, show the item type and name
|
||||
|
|
@ -692,12 +697,13 @@ def _displayItemStats(pItem1, pItem2)
|
|||
fin
|
||||
loop
|
||||
fin
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// For non-countable items, display singular name.
|
||||
// For countable "stuff" (e.g. ammo), display the count and appropriate singular or plural name.
|
||||
def _displayItemName(pItem)
|
||||
def _displayItemName(pItem)#1
|
||||
if pItem->t_type == TYPE_STUFF
|
||||
setPlural(pItem=>w_count <> 1)
|
||||
rawDisplayf1("%d ", pItem=>w_count)
|
||||
|
|
@ -705,6 +711,7 @@ def _displayItemName(pItem)
|
|||
setPlural(FALSE)
|
||||
fin
|
||||
rawDisplayf1("%s", pItem=>s_name) // use displayf to get proper plural processing
|
||||
return 0
|
||||
end
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user