can anybody post me a simple artificial intelligence sample project on path finding.

any project with a  basic search algorithm like  minmax, DFS or iterative deepening.
Please post me where can I get a sample papers on A.I topics..

please reply me fast .This is really important .

would be much helpful...

Also check the following threads.I am sorry if I am boring....


http://www.experts-exchange.com/Gamers/Computer_Games/Q_23938747.html

http://www.experts-exchange.com/Programming/Game/AI_Physics/Q_23970008.html
aditya86bAsked:
Who is Participating?
I wear a lot of hats...

"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.

cupCommented:
There is some pseudo code in http://en.wikipedia.org/wiki/Minimax#Minimax_algorithm_with_alternate_moves and
http://en.wikipedia.org/wiki/Alpha-beta_pruning

I haven't heard of DFS.  I only know of minimax, alpha-beta and m & n.  Anyway, what I know is about 30 years old.  Maybe the techniques have been improved since then.


Experts Exchange Solution brought to you by

Your issues matter to us.

Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.

Start your 7-day free trial
aditya86bAuthor Commented:
DFS means depth  first search.The search algorithm keeps growing till the end of child node
cupCommented:
Do you mind what language it is in.  I may have some in VBScript/Javascript - basically rewrites of my 1976 Algol 60 coursework.
aditya86bAuthor Commented:
java script or java
cupCommented:
Sorry, couldn't find the VBScript/Javascript version.  Here is the Fortran77 version.
Header file
! Cannibals and Missionaries
!
! Header file for common blocks
! What we are trying to achieve here is structures.  Unfortunately,
! Fortran77 does not have structures so we just use array indices
! and a two dimensional array as an array of structures.
!**********************************************************************
!     Indices
      integer ixDirn, ixParent, optm, optc
      integer miss, cann, lmiss, lcann, rmiss, rcann
      integer boatLeft, boatRight
      integer ixLo, ixHi, nodemax, opmax
      parameter (
     &    ixLo = -2,
     &    ixHi = 5,
     &    lmiss = -1,
     &    lcann = -2,
     &    ixDirn = 0,       ! direction
     &    rmiss = 1,
     &    rcann = 2,
     &    ixParent = 3,       ! parent index
     &    optm = 4,       ! optimum number of missionaries
     &    optc = 5,       ! optimum number of cannibals
     &    miss = 1,
     &    cann = 2,
     &    boatLeft = -1,   ! boat on left bank
     &    boatRight = 1,   ! boat on right bank
     &    nodemax = 27, opmax = 5)
      common /CnM/
     &     goal,
     &     boat,
     &     node,
     &     path,
     &     unexp
      integer goal(-cann:cann)         ! goal to be achieved
      integer boat(1:opmax, miss:cann) !  legal boat combinations
      integer node(1:nodemax, ixLo:ixHi)! nodes for obtaining soln
      integer path(1:nodemax)          ! the path taken
      integer unexp                    ! index of next unexpanded node
 
Source code
!!*********************************************************************
!! No Copyright - this is Freeware
!!*********************************************************************
!! File:       CnM.f
!! Author:     cup
!!
!! Purpose:
!! Cannibals and missionaries
!!
!! Three missionaries and three cannibals seek to cross a river.  A boat
!! is available which will hold two people and which can be navigated
!! by any combination of missionaries and cannibals involving one or
!! two people.  The cannibals on either bank should not at any time
!! outnumber the missionaries.  The program works out a schedule of
!! crossings that will permit all members of both parties to cross the
!! river safely.
!!
!! This is a Fortran77 conversion of an Algol 60 program I wrote
!! on 15 Dec 1976 as part of the AI module in my Computer Science
!! degree course.  It is an example of how the alpha-beta technique
!! is used.
!!
!!*********************************************************************
      program main
!      include 'CnM.h'
      integer steps
      call Initialize
      call FormPath
      call GetBestPath (steps)
      call PrintPath (steps)
      stop
      end
!**********************************************************************
! Form path.  All the boat combinations are attempted on a node.
! Any legal ones are checked for uniqueness.  If they are unique,
! they will be inserted into the list of nodes.
!**********************************************************************
      subroutine FormPath
      implicit none
!     parameters
!     common
      include 'CnM.h'
!     local
      integer expnd  ! expanded nodes
      logical across ! true when everyone is across
      logical unique ! true if the node is unique
      integer temp(ixLo:ixHi)
      integer op
      integer i
      external GeNz
      logical GeNz
 
      across = .false.
      expnd = 1
      do while (expnd .lt. unexp .and.
     &          unexp .le. nodemax .and.
     &          .not. across)
          temp(ixParent) = expnd
          temp(ixDirn) = -node(expnd,ixDirn)
!         apply the operators held in boat
          op = 1
          do while (op .le. opmax .and. .not. across)
              if (boat(op,miss) .le. node(expnd,-temp(ixDirn)) .and.
     &            boat(op,cann) .le. node(expnd,-2*temp(ixDirn))) then
!                 operator valid for this node
                  temp(optm) = boat(op,miss)
                  temp(optc) = boat(op,cann)
!                 apply the operator and check goal
                  across = goal(ixDirn) .eq. temp(ixDirn)
                  do 30 i = -cann, cann, 1
                      if (i .eq. 0) goto 30
                      temp(i) = node(expnd,i) +
     &                    isign(1, i) * temp(ixDirn)* boat(op,iabs(i))
                      across = across .and. goal(i) .eq. temp(i)
30                continue
                  if (across) then
!                     Everyone across: goal achieved
                      call InsertNode(temp)
                  else if (genz(temp(lmiss), temp(lcann)) .and.
     &                     genz(temp(rmiss), temp(rcann))) then
!                     combination is valid: is it unique?
                      unique = .true.
                      i = unexp - 1
                      do while (i .gt. 0 .and. unique)
!                         no checks are made on columns -1 and -2
!                         since they are dependent on columns 1
!                         and 2
                          unique = temp(rmiss) .ne. node(i,rmiss) .or.
     &                             temp(rcann) .ne. node(i,rcann) .or.
     &                             temp(ixDirn) .ne. node(i,ixDirn)
                          i = i - 1
                      enddo
                      if (unique) call InsertNode(temp)
                  endif
              endif
!             move to next operator
              op = op + 1
          enddo
 
!         move to the next unexpanded item
          expnd = expnd + 1
      enddo
      return
      end
!**********************************************************************
! Check if a path is legal - Greater than or equal to and Non Zero
!**********************************************************************
      logical function GeNz (iMissionary, iCannibal)
      implicit none
!     parameters
      integer iMissionary, iCannibal
 
      GeNz = (iMissionary .eq. 0) .or.
     &       (iMissionary .ge. iCannibal .and. iMissionary .ne. 0)
      return
      end
!**********************************************************************
! Get the path
!**********************************************************************
      subroutine GetBestPath (oSteps)
      implicit none
!     parameters
      integer oSteps
!     common
      include 'CnM.h'
!     local
      integer i
 
!     work backwards to find the parent from the last
!     unexpanded node
      oSteps = 1
      path(oSteps) = unexp - 1
      i = oSteps + 1
      do while (path(oSteps) .ne. 0)
          path(i) = node(path(oSteps),ixParent)
          oSteps = i
          i = i + 1
      enddo
      return
      end
!**********************************************************************
! Initialize the globals
!**********************************************************************
      subroutine Initialize
!     parameters
!     common
      include 'CnM.h'
!     local
      integer temp(ixLo:ixHi)
      
      unexp = 1              ! First unexpanded node
      temp(lmiss) = 3
      temp(lcann) = 3
      temp(rmiss) = 0
      temp(rcann) = 0
      temp(ixDirn) = boatLeft
      temp(ixParent) = 0
      temp(optc) = 0
      temp(optm) = 0
      call InsertNode (temp)
      
!     Valid combinations
      boat(1,miss) = 0
      boat(1,cann) = 2
      
      boat(2,miss) = 0
      boat(2,cann) = 1
      
      boat(3,miss) = 1
      boat(3,cann) = 1
 
      boat(4,miss) = 1
      boat(4,cann) = 0
 
      boat(5,miss) = 2
      boat(5,cann) = 0
 
!     Target to be achieved
      goal(lmiss) = 0
      goal(lcann) = 0
      goal(ixDirn)  = boatRight
      goal(rmiss) = 3
      goal(rcann) = 3
      return
      end
!**********************************************************************
! Insert one array into another
!**********************************************************************
      subroutine InsertNode (iTemp)
      implicit none
!     common
      include 'CnM.h'
!     parameters
      integer iTemp(ixLo:ixHi)
!     local
      integer i
 
      do 10 i = ixLo, ixHi, 1
          node(unexp,i) = iTemp(i)
10    continue
      unexp = unexp + 1
      return
      end
!**********************************************************************
! Print the path
!**********************************************************************
      subroutine PrintPath (iSteps)
      implicit none
!     parameters
      integer iSteps
!     common
      include 'CnM.h'
!     local
      integer i, j
      character*12 direction(boatLeft:boatRight)
      
      direction(boatLeft)  = '   -<<<<<-  '
      direction(boatRight) = '   ->>>>>-  '
      
      print *,'Initially, everyone is on the left bank'
      print *,'Msnry = number of missionaries'
      print *,'Cnnbl = number of cannibals'
      print *
      print *,'  Schedule   Direction       After Crossing'
      print *,'             of Travel   Left Bank  Right Bank'
      print *
      print *,'Msnry Cnnbl             Msnry Cnnbl Msnry Cnnbl'
      do 10 j = iSteps - 1, 1, -1
          i = path(j)
          print '(i4,i6,2x,a12,i4,3i6)',
     &        node(i,optm), node(i,optc),
     &        direction(node(i,ixDirn)),
     &        node(i,lmiss), node(i,lcann),
     &        node(i,rmiss), node(i,rcann)
10    continue
      return
      end

Open in new window

It's more than this solution.Get answers and train to solve all your tech problems - anytime, anywhere.Try it for free Edge Out The Competitionfor your dream job with proven skills and certifications.Get started today Stand Outas the employee with proven skills.Start learning today for free Move Your Career Forwardwith certification training in the latest technologies.Start your trial today
Game Programming

From novice to tech pro — start learning today.