Üye ol    Giriş
  1. Forumlar
  2. Oyunlar
  3. Ultima Online
  4. Sphere Scripting
  5. Misc scripts

Misc scripts

hwgordon
hwgordon
Neophyte
0
internetten buldugum fonksiyonlar umarım işinize yarar


//<------------------------------------------------------------------------------------->
//< ARGS=BonusTAG >--------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetCombatEffect]
LOCAL.Result="0"
FOR 1 24
IF (<LOCAL._FOR>!=9) && (<LOCAL._FOR>!=11) && (<LOCAL._FOR>!=15) && (<LOCAL._FOR>!=16) && (<LOCAL._FOR>!=21)
   LOCAL.Result = "<EVAL (<LOCAL.Result> + <FINDLAYER.<EVAL <LOCAL._FOR>>.TAG0.<ARGS>>)>"
ENDIF
ENDFOR
RETURN <LOCAL.Result>


//<------------------------------------------------------------------------------------->
//< ARGS=WeaponUID >-------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetWeaponDamage]
OBJ=<ARGS>
IF (<IsChar>) && (<OBJ>) && StrMatch("t_weapon_*","<OBJ.TYPE>") && (<OBJ.MORE1H>)
   LOCAL.DamLo=<OBJ.DAM.Hi>
   IF (<dLOCAL.DamLo> >= 1)
      LOCAL.DamLo = (<dLOCAL.DamLo>*<OBJ.MORE1L>)/<OBJ.MORE1H>
      LOCAL.DamHi = <LOCAL.DamLo> + <EVAL ((<STR>+10)/10)*2>
      RETURN <dLOCAL.DamLo>,<dLOCAL.DamHi>
   ENDIF
ENDIF
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGN=SpellID, []=Source >----------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetSpellEffect]
IF !(<ARGN>)
ELIF !(<DEF.Spell_<ARGN>_Effect>)
ELIF (<IsITEM>) // t_potion, t_weapon, t_food
   IF StrMatch("t_weapon_*","<TYPE>") || StrMatch("t_food","<TYPE>")
      LOCAL.Value = <EVAL (<DEF.Spell_<ARGN>_Effect>*<MOREZ>)/100>
   ELSE
      LOCAL.Value = <EVAL (<DEF.Spell_<ARGN>_Effect>*<MORE2>)/100>
      LOCAL.Value +=<EVAL (<LOCAL.Value>*<TOPOBJ.GetCombatEffect EnhancePotions>)/100>
   ENDIF
   RETURN <dLOCAL.Value>
ELIF (<IsCHAR>)
   IF (<ARGN>==20) || (<ARGN>==39) // Poison, Poison Field
      LOCAL.Value = <EVAL ((<DEF.Spell_<ARGN>_Effect>/2)*<OINT>)/100>
   ELSE
      LOCAL.Value = <EVAL (<DEF.Spell_<ARGN>_Effect>*<INT>)/100>
   ENDIF
   LOCAL.Value +=<EVAL (<LOCAL.Value>*<TOPOBJ.GetCombatEffect SpellIncrease>)/100>
   RETURN <dLOCAL.Value>
ENDIF
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGN=SpellID, []=Source >----------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetSpellManaUse]
IF !(<ARGN>)
ELIF !(<DEF.Spell_<ARGN>_ManaUse>)
ELIF (<IsITEM>) // t_potion, t_wand
   LOCAL.Value = <DEF.Spell_<ARGN>_ManaUse>
   LOCAL.Value -=<EVAL (<LOCAL.Value>*<TOPOBJ.GetCombatEffect LowerManaCost>)/100>
   RETURN <dLOCAL.Value>
ELIF (<IsCHAR>)
   LOCAL.Value = <DEF.Spell_<ARGN>_ManaUse>
   LOCAL.Value -=<EVAL (<LOCAL.Value>*<TOPOBJ.GetCombatEffect LowerManaCost>)/100>
   RETURN <dLOCAL.Value>
ENDIF
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGN=SpellID, []=Source >----------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetSpellCastTime]
IF !(<ARGN>)
ELIF !(<DEF.Spell_<ARGN>_CastTime>)
ELIF (<IsITEM>) // t_scroll
   LOCAL.Value = <FVAL <DEF.Spell_<ARGN>_CastTime>>
   IF (<TYPE>==t_scroll) // ??????? ?????????? ? t_scroll
      LOCAL.Value -= <FVAL (<LOCAL.Value>*25)/100>
   ENDIF
   RETURN <FVAL <LOCAL.Value>>
ELIF (<IsCHAR>)
   LOCAL.Value = <FVAL <DEF.Spell_<ARGN>_CastTime>>
   LOCAL.Value -=<FVAL (<LOCAL.Value>*<TOPOBJ.GetCombatEffect QuickCast>)/100>
   RETURN <FVAL <LOCAL.Value>>
ENDIF
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGN=SpellID, []=Source >----------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetSpellDuration]
IF !(<ARGN>)
ELIF !(<DEF.Spell_<ARGN>_Duration>)
ELIF (<IsITEM>) // t_potion, t_weapon_*, t_food
   IF StrMatch("t_weapon_*","<TYPE>") || StrMatch("t_food","<TYPE>")
      LOCAL.Value = <EVAL (<DEF.Spell_<ARGN>_Duration>*<MOREZ>)/100>
   ELSE
      LOCAL.Value = <EVAL (<DEF.Spell_<ARGN>_Duration>*<MORE2>)/100>
   ENDIF
   RETURN <dLOCAL.Value>
ELIF (<IsCHAR>)
   IF (<ARGN>==20) || (<ARGN>==39) // Poison, Poison Field
      LOCAL.Value = <EVAL (<DEF.Spell_<ARGN>_Duration>*<OINT>)/100>
   ELSE
      LOCAL.Value = <EVAL (<DEF.Spell_<ARGN>_Duration>*<INT>)/100>
   ENDIF
   RETURN <dLOCAL.Value>
ENDIF
RETURN 0


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetRealArmor]
IF (<LAYER>==6) || (<LAYER>==19) || (<LAYER>==7)
   RETURN <EVAL (<dARMOR>*10)/100>
ELIF (<LAYER>==10)
   RETURN <EVAL (<dARMOR>*5)/100>
ELIF (<LAYER>==24)
   RETURN <EVAL (<dARMOR>*25)/100>
ELIF (<LAYER>==13)
   RETURN <EVAL (<dARMOR>*40)/100>
ENDIF
RETURN <dARMOR>


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION IsArmorSet]
IF (<SRC.FINDLAYER.6.COLOR>!=<COLOR>) || (<SRC.FINDLAYER.7.COLOR>!=<COLOR>) || (<SRC.FINDLAYER.10.COLOR>!=<COLOR>) || (<SRC.FINDLAYER.13.COLOR>!=<COLOR>) || (<SRC.FINDLAYER.19.COLOR>!=<COLOR>) || (<SRC.FINDLAYER.24.COLOR>!=<COLOR>)
   RETURN 0
ELIF (<SRC.FINDLAYER.6.TYPE>!=<TYPE>) || (<SRC.FINDLAYER.7.TYPE>!=<TYPE>) || (<SRC.FINDLAYER.10.TYPE>!=<TYPE>) || (<SRC.FINDLAYER.13.TYPE>!=<TYPE>) || (<SRC.FINDLAYER.19.TYPE>!=<TYPE>) || (<SRC.FINDLAYER.24.TYPE>!=<TYPE>)
   RETURN 0
ENDIF
RETURN 1


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION DamageEquipmentWeapon]
IF !(<MORE1H>) || (<ATTR>&attr_magic)
   // Is item not have durability or magicly
ELIF (RAND(10)==0) && StrMatch("t_weapon_*","<TYPE>")
   DAMAGE 5.0
   RESENDTOOLTIP
ENDIF
RETURN 1


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION DamageEquipmentArmor]
FOR 2 25
  IF !(<FINDLAYER.<dLOCAL._FOR>.UID>) 
     // Is empty layer
  ELIF !(<FINDLAYER.<dLOCAL._FOR>.MORE1H>)
     // Is item not have durability
     IF (<FINDLAYER.<dLOCAL._FOR>.TYPE>==t_jewelry)
        FINDLAYER.<dLOCAL._FOR>.MORE1H=100
        FINDLAYER.<dLOCAL._FOR>.MORE1L=100
     ENDIF
  ELIF (<FINDLAYER.<dLOCAL._FOR>.ATTR>&attr_magic) 
     // Magicly item
  ELIF (RAND(10)==0) && StrMatch("t_armor*","<FINDLAYER.<dLOCAL._FOR>.TYPE>")
     FINDLAYER.<dLOCAL._FOR>.DAMAGE 10.0
     FINDLAYER.<dLOCAL._FOR>.RESENDTOOLTIP
  ELIF (RAND(10)==0) && StrMatch("t_shield","<FINDLAYER.<dLOCAL._FOR>.TYPE>")
     FINDLAYER.<dLOCAL._FOR>.DAMAGE 10.0
     FINDLAYER.<dLOCAL._FOR>.RESENDTOOLTIP
  ELIF (RAND(20)==0) && StrMatch("t_clothing","<FINDLAYER.<dLOCAL._FOR>.TYPE>")
     FINDLAYER.<dLOCAL._FOR>.DAMAGE 20.0
     FINDLAYER.<dLOCAL._FOR>.RESENDTOOLTIP
  ELIF (RAND(20)==0) && StrMatch("t_jewelry","<FINDLAYER.<dLOCAL._FOR>.TYPE>")
     FINDLAYER.<dLOCAL._FOR>.DAMAGE 5.0
     FINDLAYER.<dLOCAL._FOR>.RESENDTOOLTIP
  ENDIF
ENDFOR
RETURN 1


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION CreateDamageBlood]
IF (RAND(2)==0) && (<BLOODCOLOR> >= 0)
   SERV.NEWITEM=0122a
   NEW.DispID={0122a 1 0122b 1 0122c 1 0122d 1 0122e 1 0122f 1}
   NEW.P=<P>
   NEW.ATTR=attr_decay
   NEW.COLOR=<BLOODCOLOR>
   NEW.TIMER={2 20}
ENDIF


//<------------------------------------------------------------------------------------->
//< ARGS=Search UID -------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION IsHarmedBy]
FORCHARLAYER 30
IF (<BaseID>==i_memory_harmed) && (<LINK>==<ARGS>)
   RETURN 1
ENDIF
ENDFOR
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGV[0]=Search UID, ARGV[2]=DAMAGE ------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION InitHarmDamage]
FORCHARLAYER 30
  IF (<BaseID>==i_memory_harmed) && (<ARGV[0]>==<LINK>)
     MOREZ=2*60
     MORE2=<MORE2> + <QVAL (<ARGV[1]> <= <CONT.HITS>) ? <ARGV[1]>:<CONT.HITS>>
   ENDIF
ENDFOR


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetKillerByDamage]
LOCAL.mUID="0"
FORCHARLAYER 30
  IF (<BaseID>==i_memory_harmed) && (<dMORE2> > <dLOCAL.mDAM>)
     LOCAL.mDAM=<dMORE2>
     LOCAL.mUID=<LINK>
  ENDIF
ENDFOR
RETURN <LOCAL.mUID>


//<------------------------------------------------------------------------------------->
//< ARGS=UID >-------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION IsEnemy] // ??????????: 0 - ??? ??????, 1 - ??????, 2 - ????????
REF1=<ARGS>
IF (<REF1.IsGM>) || (<IsGM>)
   // ???? ?????????? ????? GM ??? ???? GM
ELIF (<NPC>)
   // ???? ?????????? NPC
   IF (<REF1.NPC>)
      RETURN <QVAL (<REF1.KARMA> < 0)?1:0> // ???? NPC ????? ????? NPC
   ELIF (<REF1.KILLS>) || (<REF1.KARMA> < -8000)
      RETURN 1 // ???? NPC ????? ?????? ?????? ??? ? ?????? ??????
   ELIF (<REF1.FLAGS>&statf_criminal)
      RETURN 2 // ???? NPC ????? ?????? ?????????
   ELIF StrMatch("c_*","<REF1.OBODY>") && (<REGION.IsEVENT.r_city_vampire_guarded>)
      RETURN 1 // ???? NPC ????? ???????? ? ???? ????????
   ELIF StrMatch("cv_*","<REF1.OBODY>") && (<REGION.IsEVENT.r_city_human_guarded>)
      RETURN 1 // ???? NPC ????? ??????? ? ???? ?????
   ENDIF
ELIF (<REF1.NPC>)
   // ???? ??????????? NPC
   IF (<REF1.KARMA> < 0)
      RETURN 1 // ???? ????? ????? ????? NPC
   ELIF StrMatch("c_*","<OBODY>") && (<REF1.REGION.IsEVENT.r_city_vampire_guarded>)
      RETURN 1 // ???? ????? ??????? ????? NPC ? ???? ????????
   ELIF StrMatch("cv_*","<OBODY>") && (<REF1.REGION.IsEVENT.r_city_human_guarded>)
      RETURN 1 // ???? ????? ?????? ????? NPC ? ???? ?????
   ENDIF
ELSE // ???? ??? ??????
   IF (<REF1.KILLS>) || (<REF1.KARMA> < -8000)
      RETURN 1 // ???? ????? ????? ?????? ?????? ??? ? ?????? ??????
   ELIF StrMatch("c_*","<OBODY>") && StrMatch("cv_*","<REF1.OBODY>")
      RETURN 1 // ???? ????? ??????? ????? ?????? ???????
   ELIF StrMatch("cv_*","<OBODY>") && StrMatch("c_*","<REF1.OBODY>")
      RETURN 1 // ???? ????? ?????? ????? ?????? ????????
   ELIF (<REF1.FLAGS>&statf_criminal) || (<REF1.FLAGS>&statf_polymorph)
      RETURN 2 // ???? ????? ????? ?????? ?????????
   ENDIF
ENDIF
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGS=UID for Check >---------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION StatusBar]
OBJ=<ARGS>
IF (<UID>==<OBJ>) || !(<IsEnemy <OBJ>>) || (<OBJ.IsGM>)
   RETURN 0
ELIF (<OBJ.FLAGS>&statf_poisoned)
   SENDPACKET 077 D<OBJ> W<OBJ.BODY> W<OBJ.P.X> W<OBJ.P.Y> <HVAL <OBJ.P.Z>> <HVAL <OBJ.DIR>> W<OBJ.COLOR> B07 06
ELIF (<OBJ.FLAGS>&statf_invul)
   SENDPACKET 077 D<OBJ> W<OBJ.BODY> W<OBJ.P.X> W<OBJ.P.Y> <HVAL <OBJ.P.Z>> <HVAL <OBJ.DIR>> W<OBJ.COLOR> B08 06
ELSE
   SENDPACKET 077 D<OBJ> W<OBJ.BODY> W<OBJ.P.X> W<OBJ.P.Y> <HVAL <OBJ.P.Z>> <HVAL <OBJ.DIR>> W<OBJ.COLOR> B01 06
ENDIF
RETURN 1


//<------------------------------------------------------------------------------------->
//< ARGV[0]=TYPE, ARGV[1]=Distance >---------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION IsNearItemType]
ARGS=<Explode :/ ,<ARGS>>
FORITEMS <dARGV[2]>
  IF StrMatch("<ARGV[1]>","<TYPE>")
     RETURN 1
  ENDIF
ENDFOR
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGS=Resources List >--------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION RS_GetRepairIngotType]
FOR 0 <EVAL <ARGV>-1>
  LOCAL.ID1=<StrArg <ARGV[<dLOCAL._FOR>]>>
  LOCAL.ID2=<StrEat <ARGV[<dLOCAL._FOR>]>>
  IF !(<LOCAL.ID1>) && !(<LOCAL.ID2>)
  ELIF (<SERV.ITEMDEF.<LOCAL.ID1>.TYPE>==t_ingot)
     RETURN <LOCAL.ID1>
  ELIF (<SERV.ITEMDEF.<LOCAL.ID2>.TYPE>==t_ingot)
     RETURN <LOCAL.ID2>
  ENDIF
ENDFOR
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGS=Resources List >--------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION RS_GetRepairIngotCount]
FOR 0 <EVAL <ARGV>-1>
  LOCAL.ID1=<StrArg <ARGV[<dLOCAL._FOR>]>>
  LOCAL.ID2=<StrEat <ARGV[<dLOCAL._FOR>]>>
  IF !(<LOCAL.ID1>) && !(<LOCAL.ID2>)
  ELIF (<SERV.ITEMDEF.<LOCAL.ID1>.TYPE>==t_ingot) && (<ISNUM <LOCAL.ID2>>)
     RETURN <LOCAL.ID2>
  ELIF (<SERV.ITEMDEF.<LOCAL.ID2>.TYPE>==t_ingot) && (<ISNUM <LOCAL.ID1>>)
     RETURN <LOCAL.ID1>
  ENDIF
ENDFOR
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGS=Resources List >--------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION RS_GetRepairLogType]
FOR 0 <EVAL <ARGV>-1>
  LOCAL.ID1=<StrArg <ARGV[<dLOCAL._FOR>]>>
  LOCAL.ID2=<StrEat <ARGV[<dLOCAL._FOR>]>>
  IF !(<LOCAL.ID1>) && !(<LOCAL.ID2>)
  ELIF (<SERV.ITEMDEF.<LOCAL.ID1>.TYPE>==t_log)
     RETURN <LOCAL.ID1>
  ELIF (<SERV.ITEMDEF.<LOCAL.ID2>.TYPE>==t_log)
     RETURN <LOCAL.ID2>
  ENDIF
ENDFOR
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGS=Resources List >--------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION RS_GetRepairLogCount]
FOR 0 <EVAL <ARGV>-1>
  LOCAL.ID1=<StrArg <ARGV[<dLOCAL._FOR>]>>
  LOCAL.ID2=<StrEat <ARGV[<dLOCAL._FOR>]>>
  IF !(<LOCAL.ID1>) && !(<LOCAL.ID2>)
  ELIF (<SERV.ITEMDEF.<LOCAL.ID1>.TYPE>==t_log) && (<ISNUM <LOCAL.ID2>>)
     RETURN <LOCAL.ID2>
  ELIF (<SERV.ITEMDEF.<LOCAL.ID2>.TYPE>==t_log) && (<ISNUM <LOCAL.ID1>>)
     RETURN <LOCAL.ID1>
  ENDIF
ENDFOR
RETURN 0


//<------------------------------------------------------------------------------------->
//< No Usage >-------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION NewSERIAL]
LOCAL.KEY=<HVAL 040000000+RAND(0ff)>
WHILE (<UID.<LOCAL.KEY>.UID>)
  LOCAL.KEY=<HVAL <LOCAL.KEY>+RAND(0ff)>
  IF (<LOCAL.KEY> >= 04fffffff)
     RETURN 0
  ENDIF
ENDIF
RETURN <LOCAL.KEY>


//<------------------------------------------------------------------------------------->
//< ARGN[1]=Count ---------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION ConsumeSelf]
IF (<AMOUNT> > 1) && (<AMOUNT> > <ARGN>)
   AMOUNT -= <QVAL (<ARGN>)?<ARGN>:1>
   UPDATE
   RESENDTOOLTIP
ELSE
   REMOVEFROMVIEW
   REMOVE
ENDIF
IF (<TDATA1>)
   SERV.NEWITEM=<TDATA1>
   NEW.BOUNCE=<SRC.UID>
ENDIF
RETURN 1


//<------------------------------------------------------------------------------------->
//< ARGS=UID --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION Melt] // Blacksmith, Retrieving resources by durablility
LOCAL.N=1
WHILE (<SERV.ITEMDEF.<BaseID>.RESOURCES.<dLOCAL.N>.VALUE>)
  IF StrMatch("*_ingot_*","<SERV.ITEMDEF.<BaseID>.RESOURCES.<dLOCAL.N>.KEY>")
     IF (<EVAL (<MORE1L>*<MORE1H>/100)> > 0)
        SERV.NEWITEM=<SERV.ITEMDEF.<BaseID>.RESOURCES.<dLOCAL.N>.KEY>
        NEW.AMOUNT=<EVAL (<SERV.ITEMDEF.<BaseID>.RESOURCES.<dLOCAL.N>.VALUE>*<EVAL (<MORE1L>*<MORE1H>/100)>)/100>
        NEW.CONT=<QVAL StrMatch("","<ARGS>")?<SRC.UID>:<ARGS>>
        LOCAL.Result = <dLOCAL.Result> + 1
     ENDIF
  ENDIF
  LOCAL.N += 1
ENDWHILE
RETURN <dLOCAL.Result>


//<------------------------------------------------------------------------------------->
//< ARGV[0]=ID, ARGV[1]=Count, ARGV[2]-Container UID] ---------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GiveItem]
IF (<ARGV>)
   LOCAL.COUNT=<ARGV[1]>
   LOCAL.ContUID=<ARGV[2]>
   LOCAL.COUNT=<QVAL (<LOCAL.COUNT>)?<LOCAL.COUNT>:1>
   IF !(<SRC.FINDLAYER.21.UID>)
      SERV.NEWITEM i_backpack,1,<SRC.UID>
   ENDIF
   WHILE (<dLOCAL.COUNT>)
    SERV.NEWITEM=<ARGV[0]>
    IF !(<SERV.ITEMDEF.<ARGV[0]>.TFLAGS>&tilef_stackable)
       LOCAL.COUNT -= 1
       NEW.CONT=<QVAL (<LOCAL.ContUID>)?<LOCAL.ContUID>:<SRC.FINDLAYER.21.UID>>
    ELIF (<dLOCAL.COUNT> > 65535)
       LOCAL.COUNT -= 65535
       NEW.AMOUNT=65535
       NEW.CONT=<QVAL (<LOCAL.ContUID>)?<LOCAL.ContUID>:<SRC.FINDLAYER.21.UID>>
    ELSE
       NEW.AMOUNT=<dLOCAL.COUNT>
       NEW.CONT=<QVAL (<LOCAL.ContUID>)?<LOCAL.ContUID>:<SRC.FINDLAYER.21.UID>>
       RETURN 1
    ENDIF
   ENDWHILE
ENDIF
RETURN 0


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION Undress]
FOR 1 24
IF (<LOCAL._FOR>==11) || (<LOCAL._FOR>==15) || (<LOCAL._FOR>==16) || (<LOCAL._FOR>==21) 
ELIF (<FINDLAYER.<dLOCAL._FOR>.UID>)
    FINDLAYER.<dLOCAL._FOR>.CONT=<FINDLAYER.21.UID>
ENDIF
ENDFOR


//<------------------------------------------------------------------------------------->
//< ARGN=Time -------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION FormatTimeFmt]
LOCAL.TimeS=<ARGN>
LOCAL.TimeM=<EVAL (<dLOCAL.TimeS>/60)>
LOCAL.TimeH=<EVAL (<dLOCAL.TimeM>/60)>
LOCAL.TimeD=<EVAL (<dLOCAL.TimeH>/24)>
LOCAL.TimeY=<EVAL (<dLOCAL.TimeD>/365)>
LOCAL.TimeS=<QVAL (<dLOCAL.TimeS> <  60)?<dLOCAL.TimeS>:<dLOCAL.TimeS>-(<dLOCAL.TimeM>*60)>
LOCAL.TimeM=<QVAL (<dLOCAL.TimeM> <  60)?<dLOCAL.TimeM>:<dLOCAL.TimeM>-(<dLOCAL.TimeH>*60)>
LOCAL.TimeH=<QVAL (<dLOCAL.TimeH> <  24)?<dLOCAL.TimeH>:<dLOCAL.TimeH>-(<dLOCAL.TimeD>*24)>
LOCAL.TimeD=<QVAL (<dLOCAL.TimeD> < 350)?<dLOCAL.TimeD>:<dLOCAL.TimeD>-(<dLOCAL.TimeY>*350)>
IF (<dARGV[1]>)
   IF (<dLOCAL.TimeY>)
      LOCAL.Result = <QVAL StrMatch("0","<LOCAL.Result>")?<dLOCAL.TimeY>y.:<dLOCAL.Result> <dLOCAL.TimeY>y.>
   ENDIF
   IF (<dLOCAL.TimeD>)
      LOCAL.Result = <QVAL StrMatch("0","<LOCAL.Result>")?<dLOCAL.TimeD>d.:<LOCAL.Result> <dLOCAL.TimeD>d.>
   ENDIF
   IF (<dLOCAL.TimeH>)
      LOCAL.Result = <QVAL StrMatch("0","<LOCAL.Result>")?<dLOCAL.TimeH>h.:<LOCAL.Result> <dLOCAL.TimeH>h.>
   ENDIF
   IF (<dLOCAL.TimeM>)
      LOCAL.Result = <QVAL StrMatch("0","<LOCAL.Result>")?<dLOCAL.TimeM>m.:<LOCAL.Result> <dLOCAL.TimeM>m.>
   ENDIF
   IF (<ARGN> < 60)
      LOCAL.Result = <QVAL StrMatch("0","<LOCAL.Result>")?<dLOCAL.TimeS>s.:<LOCAL.Result> <dLOCAL.TimeS>s.>
   ENDIF
ELSE
   LOCAL.RESULT="<dLOCAL.TimeY> years, <dLOCAL.TimeD> days, <dLOCAL.TimeH> hours <dLOCAL.TimeM> mins <dLOCAL.TimeS> sec."
ENDIF
RETURN <LOCAL.RESULT>


//<------------------------------------------------------------------------------------->
//< ARGS=UID --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION BounceUID]
IF (<SERV.UID.<ARGS>.IsItem>)
   SYSMESSAGE @33 <SERV.UID.<ARGS>.NAME> droped in your pack
   SERV.UID.<ARGS>.BOUNCE
ELIF (<SERV.UID.<ARGS>.IsChar>)
   SYSMESSAGE @33 <SERV.UID.<ARGS>.NAME> summoned to you.
   SERV.UID.<ARGS>.GO <P>
ELSE
   SYSMESSAGE @33 UID not found...
ENDIF


//<------------------------------------------------------------------------------------->
//< ARGN[0]=ClilocID, ARGV[1]=MinValue, ARGV[2]=ARGN1,ARGV[3]=ARGS2 -------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION DisplayCliloc]
IF !(<ARGN>)
ELIF (<ARGN>==1043304) && (<EVAL 0<ARGV[2]>> > 0) // Item Price
   ADDCLILOC <ARGN>,<ARGV[2]> gold
ELIF (<ARGN>==1060639) && (<EVAL 0<ARGV[3]>> > 0) // Durability
   ADDCLILOC <ARGN>,<dARGV[2]>,<dARGV[3]>
ELIF (IsNumber(<ARGV[2]>))
   IF (<ARGV[2]> > <ARGV[1]>)
      ADDCLILOC <ARGN>,<ARGV[2]>,<dARGV[3]>
   ENDIF
ELIF (IsNumber(<ARGV[3]>))
   IF (<ARGV[3]> > <ARGV[1]>)
      ADDCLILOC <ARGN>,<ARGV[2]>,<dARGV[3]>
   ENDIF
ENDIF


//<------------------------------------------------------------------------------------->
//< ARGV[0]=Bonus, ARGV[1]=Change ------------------------------------------------------>
//<------------------------------------------------------------------------------------->
[FUNCTION CreateItemMagicBonus]
IF (RAND(<dARGV[1]>)!=0)
ELIF StrMatch("t_weapon_*","<TYPE>")
   DOSWITCH RAND(14)
    LOCAL.Bonus = Luck
    LOCAL.Bonus = IncreaseGold
    LOCAL.Bonus = SkillBonus
    LOCAL.Bonus = SelfRepair
    LOCAL.Bonus = DamageSpeed
    LOCAL.Bonus = DamageFire
    LOCAL.Bonus = DamageCold
    LOCAL.Bonus = DamagePoison
    LOCAL.Bonus = DamageEnergy
    LOCAL.Bonus = DamageIncrease
    LOCAL.Bonus = CriticalDamage
    LOCAL.Bonus = LeechHits
    LOCAL.Bonus = LeechStam
    LOCAL.Bonus = LeechMana
   ENDDO
   TAG.<LOCAL.Bonus>  = <dTAG.<LOCAL.Bonus>>  + <dARGV[0]>  //  Apply Bonus
   RETURN <LOCAL.Bonus> // Return bonus name what been applied to this item
ELIF StrMatch("t_jewelry","<TYPE>")
   DOSWITCH RAND(17)
    LOCAL.Bonus = Luck
    LOCAL.Bonus = IncreaseGold
    LOCAL.Bonus = EnhancePotions
    LOCAL.Bonus = LowerManaCost
    LOCAL.Bonus = QuickCast
    LOCAL.Bonus = SpellIncrease
    LOCAL.Bonus = CriticalMagic
    LOCAL.Bonus = IncreaseStr
    LOCAL.Bonus = IncreaseDex
    LOCAL.Bonus = IncreaseInt
    LOCAL.Bonus = RegenHits
    LOCAL.Bonus = RegenStam
    LOCAL.Bonus = RegenMana
    LOCAL.Bonus = ResistCold
    LOCAL.Bonus = ResistFire
    LOCAL.Bonus = ResistPoison
    LOCAL.Bonus = ResistEnergy
   ENDDO
   TAG.<LOCAL.Bonus>  = <dTAG.<LOCAL.Bonus>>  + <dARGV[0]>  //  Apply Bonus
   RETURN <LOCAL.Bonus> // Return bonus name what been applied to this item
ELIF StrMatch("t_shield","<TYPE>")
   DOSWITCH RAND(8)
    LOCAL.Bonus = EnhancePotions
    LOCAL.Bonus = DefenseChance
    LOCAL.Bonus = ReflectArmor
    LOCAL.Bonus = ResistCold
    LOCAL.Bonus = ResistFire
    LOCAL.Bonus = ResistPoison
    LOCAL.Bonus = ResistEnergy
    LOCAL.Bonus = ResistPhysical
   ENDDO
   TAG.<LOCAL.Bonus>  = <dTAG.<LOCAL.Bonus>>  + <dARGV[0]>  //  Apply Bonus
   RETURN <LOCAL.Bonus> // Return bonus name what been applied to this item
ELSE
   DOSWITCH RAND(16)
    LOCAL.Bonus = Luck
    LOCAL.Bonus = IncreaseGold
    LOCAL.Bonus = SelfRepair
    LOCAL.Bonus = DefenseChance
    LOCAL.Bonus = ReflectArmor
    LOCAL.Bonus = IncreaseStr
    LOCAL.Bonus = IncreaseDex
    LOCAL.Bonus = IncreaseInt
    LOCAL.Bonus = RegenHits
    LOCAL.Bonus = RegenStam
    LOCAL.Bonus = RegenMana
    LOCAL.Bonus = ResistCold
    LOCAL.Bonus = ResistFire
    LOCAL.Bonus = ResistPoison
    LOCAL.Bonus = ResistEnergy
    LOCAL.Bonus = ResistPhysical
   ENDDO
   TAG.<LOCAL.Bonus>  = <dTAG.<LOCAL.Bonus>>  + <dARGV[0]>  //  Apply Bonus
   RETURN <LOCAL.Bonus> // Return bonus name what been applied to this item
ENDIF
RETURN 0


[FUNCTION FormatMagicBonus]
IF StrMatch("","<ARGS>")
   RETURN 0
ELIF StrMatch("<ARGS>","Luck")
   LOCAL.Name = "Luck"
ELIF StrMatch("<ARGS>","IncreaseGold")
   LOCAL.Name = "Gold Incerase"
ELIF StrMatch("<ARGS>","SelfRepair")
   LOCAL.Name = "Self Repair"
ELIF StrMatch("<ARGS>","SkillBonus")
   LOCAL.Name = "Skill Use Bonus"
ELIF StrMatch("<ARGS>","DamageSpeed")
   LOCAL.Name = "Swing Speed Increase"
ELIF StrMatch("<ARGS>","DamageFire")
   LOCAL.Name = "Fire Damage"
ELIF StrMatch("<ARGS>","DamageCold")
   LOCAL.Name = "Cold Damage"
ELIF StrMatch("<ARGS>","DamagePoison")
   LOCAL.Name = "Poison Damage"
ELIF StrMatch("<ARGS>","DamageEnergy")
   LOCAL.Name = "Energy Damage"
ELIF StrMatch("<ARGS>","DamageIncrease")
   LOCAL.Name = "Damage Increase"
ELIF StrMatch("<ARGS>","CriticalDamage")
   LOCAL.Name = "Critical Damage"
ELIF StrMatch("<ARGS>","LeechHits")
   LOCAL.Name = "Hit Life Leech"
ELIF StrMatch("<ARGS>","LeechStam")
   LOCAL.Name = "Hit Stamina Leech"
ELIF StrMatch("<ARGS>","LeechMana")
   LOCAL.Name = "Hit Mana Leech"
ELIF StrMatch("<ARGS>","EnhancePotions")
   LOCAL.Name = "Enhance Potions"
ELIF StrMatch("<ARGS>","LowerManaCost")
   LOCAL.Name = "Lower Mana Cost"
ELIF StrMatch("<ARGS>","QuickCast")
   LOCAL.Name = "Quick Casting"
ELIF StrMatch("<ARGS>","SpellIncrease")
   LOCAL.Name = "Spell Damage Increase"
ELIF StrMatch("<ARGS>","CriticalMagic")
   LOCAL.Name = "Critical Magic"
ELIF StrMatch("<ARGS>","IncreaseStr")
   LOCAL.Name = "Strength Increase"
ELIF StrMatch("<ARGS>","IncreaseDex")
   LOCAL.Name = "Dexterity Increase"
ELIF StrMatch("<ARGS>","IncreaseInt")
   LOCAL.Name = "Intelligence Increase"
ELIF StrMatch("<ARGS>","RegenHits")
   LOCAL.Name = "Life Regeneration"
ELIF StrMatch("<ARGS>","RegenStam")
   LOCAL.Name = "Stamina Regeneration"
ELIF StrMatch("<ARGS>","RegenMana")
   LOCAL.Name = "Mana Regeneration"
ELIF StrMatch("<ARGS>","ResistCold")
   LOCAL.Name = "Cold Resisting"
ELIF StrMatch("<ARGS>","ResistFire")
   LOCAL.Name = "Fire Resisting"
ELIF StrMatch("<ARGS>","ResistPoison")
   LOCAL.Name = "Poison Resisting"
ELIF StrMatch("<ARGS>","ResistEnergy")
   LOCAL.Name = "Energy Resisting"
ELIF StrMatch("<ARGS>","DefenseChance")
   LOCAL.Name = "Defense Chance Increase"
ELIF StrMatch("<ARGS>","ReflectArmor")
   LOCAL.Name = "Reflect Psyhical Damage"
ELSE
   LOCAL.Name = "0"
ENDIF
RETURN <LOCAL.Name>


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION SpellbookSpells]
LOCAL.Spell=1
FOR 1 32
  LOCAL.Count = <dLOCAL.Count> + <QVAL (<MORE1>&<LOCAL.Spell>)?1:0>
  LOCAL.Count = <dLOCAL.Count> + <QVAL (<MORE2>&<LOCAL.Spell>)?1:0>
  LOCAL.Spell += <LOCAL.Spell>
ENDFOR
RETURN <dLOCAL.Count>


//<------------------------------------------------------------------------------------->
//< ARGS=SkillName --------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetSkillValue]
OBJ=<UID>
FOR 0 54
  IF StrMatch("<ARGS>","<dLOCAL._FOR>")
     RETURN <OBJ.<SERV.SKILL.<dLOCAL._FOR>.KEY>>
  ELIF StrMatch("<ARGS>","<SERV.SKILL.<dLOCAL._FOR>.KEY>")
     RETURN <OBJ.<SERV.SKILL.<dLOCAL._FOR>.KEY>>
  ELIF StrMatch("<ARGS>","<SERV.SKILL.<dLOCAL._FOR>.TITLE>")
     RETURN <OBJ.<SERV.SKILL.<dLOCAL._FOR>.KEY>>
  ELIF StrMatch("<SERV.SKILL.<ARGS>.KEY>","<SERV.SKILL.<dLOCAL._FOR>.KEY>")
     RETURN <OBJ.<SERV.SKILL.<ARGS>.KEY>>
  ENDIF
ENDFOR
RETURN 0

//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GM_LockGroundItem]
TIMER = <QVAL (<TYPE>==t_spawn_char)?0:-1>
ATTR = attr_move_never
RETURN 1


//<------------------------------------------------------------------------------------->
//< ARGN=MaxCount ---------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GetEquippedNewbieCount]
FOR 1 24
// <--- Talisman ---->    <----- Light ----->    <----- Hairs ----->    <----- Beard ----->    <---- Backpack --->
IF (<dLOCAL._FOR>== 9) || (<dLOCAL._FOR>==15) || (<dLOCAL._FOR>==11) || (<dLOCAL._FOR>==16) || (<dLOCAL._FOR>==21)
//<- Check UID on layer, ant item exists or not? ->
ELIF (<FINDLAYER.<dLOCAL._FOR>.UID>)
    //<- Check layer item on next newbie attribute ->
    IF (<FINDLAYER.<dLOCAL._FOR>.ATTR>&attr_newbie)
       LOCAL.Found += 1
    ENDIF
ENDIF
ENDFOR
RETURN <dLOCAL.Found>



//<------------------------------------------------------------------------------------->
//< ARGN=ColorID ----------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION ArmorColor]
FOR 1 24
// <--- Talisman ---->    <----- Light ----->    <----- Hairs ----->    <----- Beard ----->    <---- Backpack --->
IF (<dLOCAL._FOR>== 9) || (<dLOCAL._FOR>==15) || (<dLOCAL._FOR>==11) || (<dLOCAL._FOR>==16) || (<dLOCAL._FOR>==21)
//<- Check UID on layer, ant item exists or not? ->
ELIF (<FINDLAYER.<dLOCAL._FOR>.UID>)
    //<- Check layer item on next newbie attribute ->
    FINDLAYER.<dLOCAL._FOR>.COLOR=<ARGS>
ENDIF
ENDFOR
RETURN <dLOCAL.Found>


//<------------------------------------------------------------------------------------->
//< No Usage --------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION GenerateName]
SERV.NEWITEM=i_memory
NEW.P=<SERV.ZeroPoint>
NEW.NAME = <QVAL (<OBODY>==c_man)?#NAMES_HUMANMALE:#NAMES_HUMANFEMALE>
WHILE (<NEW.NameExists <NEW.NAME>>)
NEW.NAME = <QVAL (<OBODY>==c_man)?#NAMES_HUMANMALE:#NAMES_HUMANFEMALE>
ENDWHILE
NAME = <NEW.NAME>
NEW.REMOVE
RETURN 1

//<------------------------------------------------------------------------------------->
//< ARGS=Name -------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION NameExists]
FORCHARS 6144
IF StrMatch("<NAME>","<ARGS>")
   RETURN 1
ENDIF
ENDFOR
RETURN 0


//<------------------------------------------------------------------------------------->
//< ARGN=Time >------------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION Paralyze]
TAG.NoMoveTill=<QVAL (<ARGN>)?<SERV.TIME>+<ARGN>:>


//<------------------------------------------------------------------------------------->
//< ARGN=SkillID >---------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION IsLearnedSkill]
IF (<ARGN>==18) || (<ARGN>==44) || (<ARGN>==45) || (<ARGN>==52) 
   LOCAL.Value += <QVAL (<SRC.Mining>         < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Fishing>        < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Skinning>       < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Lumberjacking>  < 100.0)?0:1>
ELSE
   LOCAL.Value += <QVAL (<SRC.Alchemy>        < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Bowcraft>       < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Carpentry>      < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Tailoring>      < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Tinkering>      < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Inscription>    < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Blacksmithing>  < 100.0)?0:1>
   LOCAL.Value += <QVAL (<SRC.Leatherworking> < 100.0)?0:1>
ENDIF
RETURN <dLOCAL.Value>


[FUNCTION GetMasteryTitle]
IF (0)
ELIF (<Alchemy> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Alchemy).TITLE>
ELIF (<Bowcraft> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Bowcraft).TITLE>
ELIF (<Carpentry> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Carpentry).TITLE>
ELIF (<Tailoring> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Tailoring).TITLE>
ELIF (<Tinkering> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Tinkering).TITLE>
ELIF (<Inscription> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Inscription).TITLE>
ELIF (<Blacksmithing> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Blacksmithing).TITLE>
ELIF (<Leatherworking> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Leatherworking).TITLE>
ELIF (<Mining> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Mining).TITLE>
ELIF (<Fishing> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Fishing).TITLE>
ELIF (<Skinning> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Skinning).TITLE>
ELIF (<Lumberjacking> >= 100.0)
   LOCAL.Title=<SERV.SKILL(Lumberjacking).TITLE>
ELSE
   LOCAL.Title=0
ENDIF
RETURN <LOCAL.Title>


//<------------------------------------------------------------------------------------->
//< ARGN=Integer ----------------------------------------------------------------------->
//<------------------------------------------------------------------------------------->
[FUNCTION FormatTime]
IF (<ARGN>)
   LOCAL.Sec = <ARGN>
   LOCAL.Min = <QVAL (<dLOCAL.Sec>)?<dLOCAL.Sec>/60:0>
   LOCAL.Hrs = <QVAL (<dLOCAL.Min>)?<dLOCAL.Min>/60:0>
   LOCAL.Day = <QVAL (<dLOCAL.Hrs>)?<dLOCAL.Hrs>/24:0>
   LOCAL.Mon = <QVAL (<dLOCAL.Day>)?<dLOCAL.Day>/30:0>
   LOCAL.Yrs = <QVAL (<dLOCAL.Mon>)?<dLOCAL.Mon>/12:0>
   LOCAL.Sec = <QVAL (<dLOCAL.Sec>)?<dLOCAL.Sec> - (<dLOCAL.Min>*60):0>
   LOCAL.Min = <QVAL (<dLOCAL.Min>)?<dLOCAL.Min> - (<dLOCAL.Hrs>*60):0>
   LOCAL.Hrs = <QVAL (<dLOCAL.Hrs>)?<dLOCAL.Hrs> - (<dLOCAL.Day>*24):0>
   LOCAL.Day = <QVAL (<dLOCAL.Day>)?<dLOCAL.Day> - (<dLOCAL.Mon>*30):0>
   LOCAL.Mon = <QVAL (<dLOCAL.Mon>)?<dLOCAL.Mon> - (<dLOCAL.Yrs>*12):0>

   IF (<dLOCAL.Min>)
      LOCAL.Result = "<dLOCAL.Min>m."
   ENDIF
   IF (<dLOCAL.Hrs>)
      LOCAL.Result = "<dLOCAL.Hrs>h. <LOCAL.Result>"
   ENDIF
   IF (<dLOCAL.Day>)
      LOCAL.Result = "<dLOCAL.Day>d. <LOCAL.Result>"
   ENDIF
   IF (<dLOCAL.Mon>)
      LOCAL.Result = "<dLOCAL.Day>/<LOCAL.Result>"
   ENDIF
   IF (<dLOCAL.Yrs>)
      LOCAL.Result = "<dLOCAL.Yrs>/<LOCAL.Result>"
   ENDIF
   RETURN <LOCAL.Result>
ENDIF
RETURN 0
  • 2008-07-21 18:06
  • #1

Üye Ol veya Giriş Yap

Bu forum başlığına mesaj atmak istiyorsanız hemen üye olun veya giriş yapın.

Discord ile Bağlan
Twitch ile Bağlan
Steam ile Bağlan
Google ile Bağlan