home *** CD-ROM | disk | FTP | other *** search
/ CyberMycha 2006 April / SGP.iso / dema / Keepsake-Demo-en-li-v1.0.exe / res / bin / common / entity.tcl < prev    next >
Text File  |  2005-10-31  |  11KB  |  472 lines
  1. proc hEntityMove { entity type pos event dist } {
  2.   if { "$event" == "wait" } {
  3.     ozEntity$entity $type [lindex $pos 0] [lindex $pos 1] [lindex $pos 2] "" 0
  4.   } else {
  5.     if { "$event" != "" && [getPlayerDistFrom [lindex $pos 0] [lindex $pos 1] [lindex $pos 2]] < $dist } {
  6.       callEvent "$event"
  7.     } else {
  8.       ozEntity$entity $type [lindex $pos 0] [lindex $pos 1] [lindex $pos 2] "$event" $dist
  9.     }
  10.   }
  11. }
  12.  
  13. proc wizEntityGetPosition { entity } {
  14.   return [ozEntity$entity get position]
  15. }
  16.  
  17. proc wizEntityGetClickPosition { entity } {
  18.   return [ozEntity$entity get clickposition]
  19. }
  20.  
  21. proc wizEntitySetPosition { entity pos } {
  22.   ozEntity$entity set position [lindex $pos 0] [lindex $pos 1] [lindex $pos 2]
  23. }
  24.  
  25. proc wizEntitySetPositionRelative { entity p1 q1 p2 q2 } {
  26.   set p1x [lindex $p1 0]
  27.   set p1y [lindex $p1 1]
  28.   set p1z [lindex $p1 2]
  29.  
  30.   set q1x [lindex $q1 0]
  31.   set q1y [lindex $q1 1]
  32.   set q1z [lindex $q1 2]
  33.  
  34.   set p2x [lindex $p2 0]
  35.   set p2y [lindex $p2 1]
  36.   set p2z [lindex $p2 2]
  37.  
  38.   set q2x [lindex $q2 0]
  39.   set q2y [lindex $q2 1]
  40.   set q2z [lindex $q2 2]
  41.  
  42.   set t [wizEntityGetPosition $entity]
  43.   set tx [lindex $t 0]
  44.   set ty [lindex $t 1]
  45.   set tz [lindex $t 2]
  46.   
  47.   set r [ozSystem projection $tx $ty $tz $p1x $p1y $p1z $q1x $q1y $q1z]
  48.   set r [wizClamp $r 0 1]
  49.   
  50.   set rx [wizRelative $r 0 1 $p2x $q2x]
  51.   set ry [wizRelative $r 0 1 $p2y $q2y]
  52.   set rz [wizRelative $r 0 1 $p2z $q2z]
  53.   
  54.   wizEntitySetPosition $entity "$rx $ry $rz"
  55. }
  56.  
  57. proc wizEntitySetOrientation { entity o } {
  58.   eval [subst {
  59.     ozEntity$entity set orientation [expr $o * [PI] / 180.0]
  60.   }]
  61. }
  62.  
  63. proc wizEntityOrientation { entity o { event "" } } {
  64.   eval [subst {
  65.     ozEntity$entity orientation [expr $o * [PI] / 180.0] "$event"
  66.   }]
  67. }
  68.  
  69. proc wizEntityMove { entity pos { event "" } { dist 10 }} {
  70.   hEntityMove $entity move "$pos" "$event" $dist
  71. }
  72.  
  73. proc wizEntityWalk { entity pos { event "" } { dist 10 } } {
  74.   hEntityMove $entity walk "$pos" "$event" $dist
  75. }
  76.  
  77. proc wizEntityRun { entity pos { event "" } { dist 10 } } {
  78.   hEntityMove $entity run "$pos" "$event" $dist
  79. }
  80.  
  81. proc wizEntityAction { entity action } {
  82.   ozEntity$entity action $action
  83. }
  84.  
  85. proc wizEntitySetSprintDistance { entity distance } {
  86.   ozEntity$entity set s[expr $a / $PI * 180.0]printDistance $distance
  87. }
  88.  
  89. proc wizEntitySetSprintSpeed { entity speed } {
  90.   ozEntity$entity set sprintSpeed $speed
  91. }
  92.  
  93. proc wizEntitySetWalkSpeed { entity speed } {
  94.   ozEntity$entity set walkSpeed $speed
  95. }
  96.  
  97. proc wizEntityMoveXRelative { entity min max p q { event "" } { dist 10 } } {
  98.   set px [lindex $p 0]
  99.   set py [lindex $p 1]
  100.   set pz [lindex $p 2]
  101.  
  102.   set qx [lindex $q 0]
  103.   set qy [lindex $q 1]
  104.   set qz [lindex $q 2]
  105.  
  106.   set t [lindex [ozSystem getpanmouseclick] 0]
  107.   
  108.   set t [expr ( 1 / ($max - $min) ) * ($t - $min)]
  109.   set t [wizClamp $t 0 1]
  110.   
  111.   set x [wizRelative $t 0 1 $px $qx]
  112.   set y [wizRelative $t 0 1 $py $qy]
  113.   set z [wizRelative $t 0 1 $pz $qz]
  114.  
  115.   wizEntityMove $entity "$x $y $z" "$event" $dist
  116. }
  117.  
  118. proc wizEntityMoveYRelative { entity min max p q { event "" } { dist 10 } } {
  119.   set px [lindex $p 0]
  120.   set py [lindex $p 1]
  121.   set pz [lindex $p 2]
  122.  
  123.   set qx [lindex $q 0]
  124.   set qy [lindex $q 1]
  125.   set qz [lindex $q 2]
  126.  
  127.   set t [lindex [ozSystem getpanmouseclick] 1]
  128.  
  129.   set t [expr ( 1 / ($max - $min) ) * ($t - $min)]
  130.   set t [wizClamp $t 0 1]
  131.  
  132.   set x [wizRelative $t 0 1 $px $qx]
  133.   set y [wizRelative $t 0 1 $py $qy]
  134.   set z [wizRelative $t 0 1 $pz $qz]
  135.  
  136.   wizEntityMove $entity "$x $y $z" "$event" $dist
  137. }
  138.  
  139. proc wizqEntityMove { entity pos { event "" } { dist 10 } } {
  140.   eval [subst {
  141.     chainEvent {
  142.       wizEntityMove $entity "$pos" "$event" $dist
  143.     }
  144.     if { "$event" == "wait" } {
  145.       chainEvent {
  146.         if { \[ozEntity$entity isidle] == 0 } {
  147.           eventState wait
  148.         }
  149.       }
  150.     }
  151.   }]
  152. }
  153.  
  154. proc wizqEntityWalk { entity pos { event "" } { dist 10 } } {
  155.   eval [subst {
  156.     chainEvent {
  157.       wizEntityWalk $entity "$pos" "$event" $dist
  158.     }
  159.     if { "$event" == "wait" } {
  160.       chainEvent { 
  161.         if { \[ozEntity$entity isidle] == 0 } {
  162.           eventState wait
  163.         }
  164.       }
  165.     }
  166.   }]
  167. }
  168.  
  169. proc wizqEntityRun { entity pos { event "" } { dist 10 } } {
  170.   eval [subst {
  171.     chainEvent {
  172.       wizEntityRun $entity "$pos" "$event" $dist
  173.     }
  174.     if { "$event" == "wait" } {
  175.       chainEvent { 
  176.         if { \[ozEntity$entity isidle] == 0 } {
  177.           eventState wait
  178.         }
  179.       }
  180.     }
  181.   }]
  182. }
  183.  
  184. proc wizqEntityAction { entity action { event "" } } {
  185.   eval [subst {
  186.     chainEvent {
  187.       wizEntityAction $entity $action
  188.       if { "$event" == "wait" } {
  189.         delay [wizEntityGetActionTime $entity $action]
  190.       }
  191.     }
  192.   }]
  193. }
  194.  
  195. proc wizqEntitySetOrientation { entity o } {
  196.   eval [subst {
  197.     chainEvent {
  198.       wizEntitySetOrientation $entity $o
  199.     }
  200.   }]
  201. }
  202.  
  203. proc wizqEntityOrientation { entity o { event "" } } {
  204.   eval [subst {
  205.     chainEvent {
  206.       if { "$event" == "wait" } {
  207.         wizEntityOrientation $entity $o
  208.       } else {
  209.         wizEntityOrientation $entity $o $event
  210.       }
  211.     }
  212.     if { "$event" == "wait" } {
  213.       chainEvent { 
  214.         if { \[ozEntity$entity isidle] == 0 } {
  215.           eventState wait
  216.         }
  217.       }
  218.     }
  219.   }]
  220. }
  221.  
  222. proc wizEntityAddCycle { entity cycle } {
  223.   ozEntity$entity addcycle $cycle
  224. }
  225.  
  226. proc wizqEntityAddCycle { entity cycle} {
  227.   eval [subst {
  228.     chainEvent {
  229.       wizEntityAddCycle $entity $cycle
  230.     }
  231.   }]
  232. }
  233.  
  234. proc wizEntityRemoveCycle { entity cycle } {
  235.   ozEntity$entity removecycle $cycle
  236. }
  237.  
  238. proc wizqEntityRemoveCycle { entity cycle } {
  239.   eval [subst {
  240.     chainEvent {
  241.       wizEntityRemoveCycle $entity $cycle
  242.     }
  243.   }]
  244. }
  245.  
  246. proc wizEntityLookAt { entity lookpos { event "" } } {
  247.   set entitypos [ozEntity$entity get position]
  248.  
  249.   set ex [lindex $entitypos 0]
  250.   set ey [lindex $entitypos 1]
  251.   set ez [lindex $entitypos 2]
  252.  
  253.   set lx [lindex $lookpos 0]
  254.   set ly [lindex $lookpos 1]
  255.   set lz [lindex $lookpos 2]
  256.  
  257.   if {[expr abs($ex - $lx) + abs($ey - $ly) + abs($ez - $lz)] < 0.0001} {
  258.       
  259.       return
  260.   }
  261.  
  262.   set a [ozSystem mathangle $ex $ey $ez $lx $ly $lz]
  263.   
  264.   wizEntityOrientation $entity [expr $a / [PI] * 180.0] "$event"
  265. }
  266.  
  267. proc wizqEntityLookAt { entity lookpos } {
  268.   set entitypos [ozEntity$entity get position]
  269.  
  270.   set ex [lindex $entitypos 0]
  271.   set ey [lindex $entitypos 1]
  272.   set ez [lindex $entitypos 2]
  273.  
  274.   set lx [lindex $lookpos 0]
  275.   set ly [lindex $lookpos 1]
  276.   set lz [lindex $lookpos 2]
  277.  
  278.   if {[expr abs($ex - $lx) + abs($ey - $ly) + abs($ez - $lz)] < 0.0001} {
  279.       return
  280.   }
  281.       
  282.   set a [ozSystem mathangle $ex $ey $ez $lx $ly $lz]
  283.  
  284.   wizqEntityOrientation $entity [expr $a / [PI] * 180.0]
  285. }
  286.  
  287. proc wizEntityHide { entity } {
  288.   ozEntity$entity hide
  289. }
  290.  
  291. proc wizEntityShow { entity } {
  292.   ozEntity$entity show
  293. }
  294.  
  295. proc wizqEntityHide { entity } {
  296.   eval [subst {
  297.     chainEvent {
  298.       wizEntityHide $entity
  299.     }
  300.   }]
  301. }
  302.  
  303. proc wizqEntityShow { entity } {
  304.   eval [subst {
  305.     chainEvent {
  306.       wizEntityShow $entity
  307.     }
  308.   }]
  309. }
  310.  
  311. proc wizEntityStopFollow { entity } {
  312.   ozEntity$entity stopfollow
  313. }
  314.  
  315. proc wizEntityResumeFollow { entity } {
  316.   ozEntity$entity resumefollow
  317. }
  318.  
  319. proc wizqEntityStopFollow { entity } {
  320.   eval [subst {
  321.     chainEvent {
  322.       wizEntityStopFollow $entity
  323.     }
  324.   }]
  325. }
  326.  
  327. proc wizqEntityResumeFollow { entity } {
  328.   eval [subst {
  329.     chainEvent {
  330.       wizEntityResumeFollow $entity
  331.     }
  332.   }]
  333. }
  334.  
  335. proc wizEntityStop { entity } {
  336.   ozEntity$entity stop
  337. }
  338.  
  339. proc wizqEntityStop { entity } {
  340.   eval [subst {
  341.     chainEvent {
  342.       wizEntityStop $entity
  343.     }
  344.   }]
  345. }
  346.  
  347. proc wizEntityGetActionTime { entity action } {
  348.   return [ozEntity$entity get actiontime $action]
  349. }
  350.  
  351. proc wizEntitySetCycle { entity cycle } {
  352.   ozEntity$entity setcycle $cycle
  353. }
  354.  
  355. proc wizqEntitySetCycle { entity cycle} {
  356.   eval [subst {
  357.     chainEvent {
  358.       wizEntitySetCycle $entity $cycle
  359.     }
  360.   }]
  361. }
  362.  
  363. proc wizEntitySetWalkSpeed { entity speed } {
  364.   ozEntity$entity set walkSpeed $speed
  365. }
  366.  
  367. proc wizEntitySetSprintSpeed { entity speed } {
  368.   ozEntity$entity set sprintSpeed $speed
  369. }
  370.  
  371. proc wizEntityGetWalkSpeed { entity } {
  372.   return [ozEntity$entity get walkSpeed]
  373. }
  374.  
  375. proc wizEntityGetSprintSpeed { entity } {
  376.   return [ozEntity$entity get sprintSpeed]
  377. }
  378.  
  379. proc wizqEntityChangeWalkSpeed { entity speed } {
  380.     if { $speed == "default" } {
  381.         eval [subst {
  382.             chainEvent {
  383.                 if { \[info exists ::${entity}DefaultWalkSpeed] } {
  384.                     wizEntitySetWalkSpeed $entity \[set ::${entity}DefaultWalkSpeed]
  385.                 }
  386.             }
  387.         }]
  388.         return
  389.     }
  390.         
  391.     eval [subst {
  392.         chainEvent {
  393.             if { !\[info exists ::${entity}DefaultWalkSpeed] } {
  394.                 set ::${entity}DefaultWalkSpeed [wizEntityGetWalkSpeed $entity]
  395.             }
  396.             wizEntitySetWalkSpeed $entity $speed
  397.         }
  398.     }]
  399. }
  400.  
  401. proc wizqEntityChangeSprintSpeed { entity speed } {
  402.     if { $speed == "default" } {
  403.         eval [subst {
  404.             chainEvent {
  405.                 if { \[info exists ::${entity}DefaultSprintSpeed] } {
  406.                     wizEntitySetSprintSpeed $entity \[set ::${entity}DefaultSprintSpeed]
  407.                 }
  408.             }
  409.         }]
  410.         return
  411.     }
  412.         
  413.     eval [subst {
  414.         chainEvent {
  415.             if { !\[info exists ::${entity}DefaultSprintSpeed] } {
  416.                 set ::${entity}DefaultSprintSpeed [wizEntityGetSprintSpeed $entity]
  417.             }
  418.             wizEntitySetSprintSpeed $entity $speed
  419.         }
  420.     }]
  421. }
  422.  
  423. proc wizEntitySetOrientationTarget { entity target } {
  424.     ozEntity$entity set target $target
  425. }
  426.  
  427. proc wizqEntitySetOrientationTarget { entity target } {
  428.     eval [subst {
  429.         chainEvent {
  430.             wizEntitySetOrientationTarget $entity $target
  431.         }
  432.     }]
  433. }
  434.  
  435. proc wizqEntityChangeCycle { entity cycle action { event "" } } {
  436.   eval [subst {
  437.     wizqEntityAction $entity $action
  438.     chainEvent { delay 250 }
  439.     wizqEntitySetCycle $entity $cycle
  440.     if { "$event" == "wait" } {
  441.       chainEvent { 
  442.         delay [expr [wizEntityGetActionTime $entity $action]-250]
  443.       }
  444.     }
  445.   }]
  446. }
  447.  
  448. proc wizqEntityEnableBackWalk { entity } {
  449.   eval [subst {
  450.     chainEvent { ozEntity$entity enablebackwalk }
  451.   }]
  452. }
  453.  
  454. proc wizqEntityDisableBackWalk { entity } {
  455.   eval [subst {
  456.     chainEvent { ozEntity$entity disablebackwalk }
  457.   }]
  458. }
  459.  
  460. proc wizqEntityModel { entity model} {
  461.   eval [subst {
  462.     chainEvent {ozEntity$entity model $model}
  463.   }]
  464. }
  465.  
  466. proc wizqEntityFollowNormal { entity bool } {
  467.   eval [subst {
  468.     chainEvent {ozEntity$entity follownormal $bool}
  469.   }]
  470. }
  471.  
  472.