JESS: exist and test functions

[sandy ngai]

I am building an expert rule engine to play a card game UNO.

;;these are the facts of a card hand: [expect to have 1+ cards in hand]
(deftemplate hand (slot name)(slot value))
 
;;This is the leading card:[expect to have only 1 card in pile] 
(deftemplate pile (slot name)(slot value))
 
------------------------------------------
 ;;phase is to control which section of the rules to fire:
(deftemplate phase (slot isPhase))
 
;;YES or No value here for whether the next player is a threat or not:
(deftemplate nxt (slot isDangerous)) 
 
;;Facts of the type of play style allowd 
(deftemplate can-play (slot type))
 
-------------------------------------------
 
So i have an inital rule that's fired to set up certain facts
 
(defrule MAIN::initial
    "Set phase to check for normal best rules initially 
    if player is not dangerous"    
        
    ?p <- (phase (isPhase ?init&~best&~special&~final))
    ?danger <- (nxt(isDangerous ?nxt-player))
    (test (?nxt-player contains no))
    (pile (name ?na)(value ?va))
=>
    (printout t "dangerous? "?danger crlf)
    (retract ?p)
    
    (printout t "initial..." crlf)
    (printout t "Phase " ?init crlf);
    (printout t "Pile name: "?na " & val: "?va crlf)
    (bind ?*n* ?na)
    (bind ?*v* ?va)
    (assert (phase (isPhase best)))
    (facts)
)
 
******************
******************
What is not working and i don't understand why is this part:
 
;;------------------------------------------------
;; Possible ways of playiny (not the specific card)
;;------------------------------------------------
(defrule MAIN: :D ifferent-color
 
    (MAIN::nxt (isDangerous ?nxt-player&~yes))
    (hand (name ?n&~?*n*))
    (exists (hand (value ?*v*)))
    (MAIN: :pile(value ?v))
    (not(test (?v contains d4)))
    (not(test(?v contains d2)))
    ?p <- (MAIN::phase (isPhase best ))
    (not(exists (can-play (type diff-color)) ))   
   =>
    (printout t "Differenct color : " crlf)
    (assert (can-play (type diff-color)))
)
 
(defrule MAIN::same-color
    (MAIN::nxt(isDangerous ?nxt-player&~yes))    
    ?p <- (MAIN::phase (isPhase best))
    (hand (name ?n))
    (test (?n contains ?*n*))
    (exists (hand (name ?*n*)))
    (MAIN::pile(value ?v))
    (not(test(?v contains d4)))
    (not(test(?v contains d2)))
    (not(exists (can-play (type same-color))))
=>
    (printout t "Same Color" crlf)
    (assert (can-play (type same-color)))
)
 
-----------------------
RESULT
f-0   (MAIN::hand (name "r") (value "2"))
f-1   (MAIN::hand (name "b") (value "5"))
f-2   (MAIN::hand (name "b") (value "3"))
f-3   (MAIN::hand (name "b") (value "4"))
f-4   (MAIN: :pile (name "r") (value "5"))
f-5   (MAIN::nxt (isDangerous "no"))
f-8   (MAIN::can-play (type same-color))
For a total of 7 facts in module MAIN.
 
(can-play (type diff-color))  
      ---- expect this to show but it doesn't. 
            So obviously this didn't fire
 
same color - where hand(name) same as pile(name)
diff color - where hand(name) not important, hand(value) must be same as 
                                             pile(value)
 
-----------------------------------
different color fires when there's no same color and visa versa. but I want 
both of them to fire when their conditions are met. 

Did I write jess wrong? or maybe just my whole concept of it is wrong.
help me.. please...

[ EJFH: Turned off smilies for this post; Added [CODE ][ /CODE] tags to preserve formatting, and HTML escapes. ]
[ March 12, 2006: Message edited by: Ernest Friedman-Hill ]

[Ernest Friedman-Hill]

Hi,

Welcome to JavaRanch!

It's hard for me to tell exactly what you want to do here; there are a lot of things that don't make sense. For example, the value slots of the existing "hand" facts all contain Strings, but your rules seem to be trying to call a "contains" method on those Strings; the String class has no such method.

I can tell you a few things that you're doing that can lead to problems, and maybe this advice will help you clear things up. For example, you seem to be mixing quoted Strings and unquoted symbols very liberally. Note that they're different data types in Jess: "yes" and yes are two different items and one won't match the other.

Another thing is just a silly thing: "not" means something does not exist. "exists" means it does exist, and it's implemented as "not not" -- i.e., something exists if it does not not exist. Writing "not exists" sounds like good english, but in Jess it means "not not not" -- which is just a very ineffificient way of writing "not".

I see some variables of the form ?*v* normally reserved for defglobals, but I don't see their declarations anywhere -- they are defglobals, right? Note that pattern matching is driven by working memory changes; changing the value of a defglobal will not cause matches to be reevaluated later.

[sandy ngai]

Thanks for your quick reply. I am so lost without proper help.

I do have my defglobals declared (just forgot to include it there.) and i admit i really don't have much of a clue in what i'm doing with the "exist".

(not(exists (can-play (type "diff-color")) ))
-- I'm trying to say, where fact (can-play (type)) does not contain any fact "diff-color". So how should i rewrite this?

- (not(can-play (type "diff-color"))) ?


You said that "yes" and yes is different, meaning yes is a symbol and "yes" is a string. so the code above is now checking "can-play" with a string not a symbol?

Well i took all of the conditions out of the two rules "same-color" and "different-color" except for the ?p-(MAIN: hase (isPhase best )). So they have the exact same conditions but only the "different-color" rule is being fired. why is that?

[Ernest Friedman-Hill]

If two rules have the exact same conditions, both will fire, as long as their actions don't invalidate the conditions. I can't explain your observations other than to suggest that you may have a typo of some kind.

Yes, "(not(exists (can-play (type "diff-color")) ))" and " (not(can-play (type "diff-color")))" mean the same thing.