Python Helper.ppack方法代码示例

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def findBestPushTrackTo(self, pgs, dof, pgdp, pp, box_from, box_to):
    bfp=hlp.ppack(box_from[0], box_from[1])
    btp=hlp.ppack(box_to[0],   box_to[1])

    if bfp not in pgdp:                               # wenn auf der StartPos box_from keine Box steht...
      return(1, "")                                   # ...dann kommen wir hier nicht weiter
    if pgs[box_to[1]][box_to[0]]=="#" or btp in pgdp: # wenn die ZielPos box_to nicht frei ist...
      return(2, "")                                   # ...dann kommen wir hier nicht weiter

    # Hier wird eine Kopie des statischen Spielfeldes erzeugt, in der alle Boxen ausser
    # der zu schiebenden Box box_from als Walls enthalten sind.
    pgst=[]
    for y in range(len(pgs)):
      ln=[]
      for x in range(len(pgs[y])):
        c=pgs[y][x]
        if hlp.ppack(x, y) in pgdp:
          if box_from!=(x, y):
            c="#"
        ln.append(c)
      pgst.append(ln)

    queue=deque([])
    visited={}
    for d in range(4):
      if pgst[pp[1]+self.my[d]][pp[0]+self.mx[d]]!="#":
        queue.append((bfp, pp, d, ""))    # (BoxPosPacked, PlayerPos, Schieberichtung, Bewegungsstring)
        visited.update({(bfp, pp, d):1})  # (BoxPosPacked, PlayerPos, Schieberichtung)

    pushed=False
    while queue:
      pgdp, pp, d, ks=queue.popleft()
      pgdpl=[pgdp]
      rc, ms, pp, bp, isdead=self.movePlayer(pgst, dof, pgdpl, pp, d)
      pgdp=pgdpl[0] # ggf. geänderte BoxPos holen

      if rc==2:
        pushed=True

      if btp==pgdp:       # wenn Box das Zielfeld erreicht hat...
        return(0, ks+ms)  # ...fertig

      if rc!=0:                                                 # wenn der movePlayer einen legalen Zug meldet...
        for d in range(4):                                      # ...alle vier möglichen Folgezüge...
          if (pgdp, pp, d) not in visited:                      # ...testen, ob sie schon probiert wurden...
            if pgst[pp[1]+self.my[d]][pp[0]+self.mx[d]]!="#":   # ...und legal sind...
              queue.append((pgdp, pp, d, ks+ms))                # ...wenn ja, dann zum weiteren Testen auf die Queue
              visited.update({(pgdp, pp, d):1})

    if pushed==False:
      return(4, "")
    return(5, "")

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
 def leftButtonStillDown(self):
   if self.dragdrop==True:
     if hlp.ppack(self.from_x, self.from_y) in self.pg_dynp:
       csr=wx.StockCursor(wx.CURSOR_HAND)
     else:
       csr=wx.StockCursor(wx.CURSOR_NO_ENTRY)
     self.SetCursor(csr)

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def findGoodFloors(self):
    good_floors=[]
    for gsx, gsy in self.zfl:     # für jedes Zielfeld...
      pgdpt=[hlp.ppack(gsx, gsy)] # ...eine Box drauf setzen
      rlst=self.__pullableBordersForSingleBox(gsx, gsy) # mögliche inverse Züge bestimmen
      # rlst kann 0 bis 4 Elemente enthalten
      for p in rlst:
        pgdpt=[hlp.ppack(gsx, gsy)] # neu setzen, weil pgdpt von __findGoodFloorsForSingleBox geändert wird
        good_floors=self.__findGoodFloorsForSingleBox(pgdpt, p, self.pp, good_floors)

    rc=[]
    for i in good_floors:     # aus der Liste mit Pulls eine Liste von Floors machen
      (dp, d)=hlp.munpack(i)
      if dp not in rc:
        rc.append(dp)
    return(rc)

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def showPlayground(self, dc, clearDC, pgs, dof, pgdp, pp, size, isDeadList, markDeadBoxes, sol_mode):
    self.dc=dc
    self.__resize(size)

    self.dc.SetBackground(wx.Brush(self.col_dict["col_bg"]))
    if clearDC==True:
      self.dspc.clearCache()
      self.dc.Clear()

    for y in range(size[1]):
      rand=False
      for x in range(size[0]):
        s=pgs[y][x]
        if s not in (" ", "_"):
          rand=True
        isdead=False
        debug=-1
#        debug=dof[y][x]#&0x00FF
        d=""
        if hlp.ppack(x, y) in pgdp:
          d="$"
          if markDeadBoxes==True:
            isdead=(x, y) in isDeadList # nur Boxen können tot sein

        if pp==(x, y):
          d="@"
        if self.dspc.getCache(x, y)!=[s, d, isdead, debug, sol_mode]: # wenn Änderung zu DisplayCache...
          self.showObject(s, d, x, y, rand, isdead, debug, markDeadBoxes, sol_mode)
          self.dspc.setCache(x, y, [s, d, isdead, debug, sol_mode]) # Ausgaben im DisplayCache merken

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def findPossiblePushes(self, pgs, pgdp, playerpos):
    rlst=[]
    floors, bList=self.__findReachableBoxes(pgs, pgdp, playerpos)

    for b in bList:             # über alle erreichbaren Boxen
      bx, by=hlp.punpack(b)
      for r in range(4):        # über alle Schiebe-Koordinaten
        x=bx+self.rp[r][0]
        y=by+self.rp[r][1]      # Player-Pos für aktuelle Schiebe-Richtung
        xyp=hlp.ppack(x, y)
        if xyp in floors:       # wenn Player-Pos innerhalb der erreichbaren Felder...
          xh=bx+self.pt[r][0]   # x,y für schnellen Vortest, ob Zug legal sein wird....
          yh=by+self.pt[r][1]
          if pgs[yh][xh] not in ("#", "_"):
            # es wird nicht gegen eine Wall oder auf badFloor geschoben
            if hlp.ppack(xh, yh) not in pgdp:
              # es wird nicht gegen eine Box geschoben
              rlst.append((xyp<<2)+self.sr[r]) # also Zug zum weiteren testen vormerken
    return(rlst)

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
 def updateDegreeOfFreedom(self, dof, pgd):
   for y in range(len(dof)):
     for x in range(len(dof[y])):
       if dof[y][x]>=0x1000:     # wenn überquerbares Feld
         dof[y][x]&=0x1F0F                   # dynamischen DOF löschen
         dof[y][x]|=((dof[y][x]&0x000F)<<4)  # dynamischer DOF auf statischer DOF setzen
         for r in range(4):      # über die vier Nachbarfelder
           nx=x+self.rtg[r][0]
           ny=y+self.rtg[r][1]
           if hlp.ppack(nx, ny) in pgd:      # wenn auf dem Nachbarfeld eine Box steht
             dof[y][x]&=self.msk_box[r]

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
 def inverseMovePlayer(self, pgs, pgd, pp, d):
   np=(pp[0]+self.mx[d], pp[1]+self.my[d])     # Koordinaten Player-Zielfeld
   if pgs[np[1]][np[0]]!="#":                  # kein Wall auf dem Player-Zielfeld
     if hlp.ppackt(np) not in pgd:             # und keine Box auf dem Player-Zielfeld
       bp=hlp.ppack(pp[0]+self.ix[d], pp[1]+self.iy[d])   # Koordinaten Box-Startfeld
       if bp in pgd:                           # ziehbare Box am Player-Startfeld
         pgd.remove(bp)
         pgd.append(hlp.ppackt(pp))
         return((2, np))
       else:
         return((1, np))
   return((0, pp))

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def findAreas(self, pgs, pgdp):
    floorsList=[[]]
    boxesList=[[]]
    for y in range(len(pgs)):
      for x in range(len(pgs[y])):
        if pgs[y][x] in (" ", "_", ".") and hlp.ppack(x, y) not in pgdp:
          floorFound=False
          for l in floorsList:
            if hlp.ppack(x, y) in l:
              floorFound=True
              break
          if floorFound==False:
            floors, boxes=self.__findReachableBoxes(pgs, pgdp, (x, y))
            floorsList.append(floors)
            boxesList.append(boxes)

    for l in floorsList:
      o=[]
      for i in l:
        o.append(hlp.punpack(i))
      print sorted(o)

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
 def findAreas(self, pgs, pgdp):
   floorsList=[]
   boxesList=[]
   for y in range(len(pgs)):
     for x in range(len(pgs[y])):
       if pgs[y][x] in (" ", "_"):
         for l in floorsList:
           if hlp.ppack(x, y) not in l:
             floors, boxes=self.__findReachableBoxes(pgs, pgdp, (x, y))
             floorList.append(floors)
             boxesList.append(boxes)
   for l in floorsList:
     print l

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def GetObj(self, pgs, pgdp, pp, x, y):
    if   y>=len(pgs)    or y<0:  rc="u" # ausserhalb des Spielfeldes ist alles Wall
    elif x>=len(pgs[0]) or x<0:  rc="u" # nicht alle Zeilen müssen die volle Länge haben
    else:                        rc=pgs[y][x]

    if rc=="_":
      rc=" "

    if (x, y)==pp:                # wenn der Player auf dieser Position steht...
      if rc==".":   rc="+"        # ...wenn es ein Goal square ist, liefere Player on Goal square
      else:         rc="@"        # ...wenn es Floor ist, liefere Player
    elif hlp.ppack(x, y) in pgdp: # wenn an der Position etwas dynamisches steht...
      if   rc==".": rc="*"        # ...wenn es ein Goal square ist, liefere Box on Goal square
      elif rc==" ": rc="$"        # ...wenn es Floor ist, liefere Box
    return(rc)

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
 def reconvertPlayground(self, pg_stat, size, pg_dynp, playerpos):
   pg=[]
   for y in range(size[1]):
     ln=[]
     for x in range(size[0]):
       c=pg_stat[y][x]
       if hlp.ppack(x, y) in pg_dynp:
         if   c==" ":  c="$"
         elif c==".":  c="*"
       elif (x, y)==playerpos:
         if   c==" ":  c="@"
         elif c==".":  c="+"
       ln.append(c)
     pg.append(ln)
   return(pg)

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def __finalizeDegreeOfFreedom(self, pgs, dof, pgdp, pp):
    rlst=[]
    floors, bList=self.__findReachableBoxes(pgs, pgdp, pp)

    for b in bList:             # über alle erreichbaren Boxen
      bx, by=hlp.punpack(b)

      dof[by][bx]&=0x10FF
      for r in range(4):        # über alle Schiebe-Koordinaten
        x=bx+self.rp[r][0]
        y=by+self.rp[r][1]      # Player-Pos für aktuelle Schiebe-Richtung
        xyp=hlp.ppack(x, y)
        if xyp in floors:       # wenn Player-Pos innerhalb der erreichbaren Felder...
#          rlst.append(((bx, by), self.sr[r]))
#          dof[by][bx]|=self.sm[r]
          dof[by][bx]|=(self.sm[r] & ((dof[by][bx]&0x00F0)<<4))

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  def convertPlayground(self, pg, size):
    pg_stat=[]
    pg_dynp=[]
    playerpos=()

    for y in range(size[1]):
      ln=[]
      for x in range(size[0]):
        if pg[y][x] in ("#", " ", "."):   # Mauer, Boden, Zielfeld
          ln.append(pg[y][x])
        if pg[y][x] in ("*", "+"):        # Box/Spielfigur auf Zielfeld
          ln.append(".")
        if pg[y][x] in ("@", "$"):        # Spielfigur oder Box
          ln.append(" ")
        if pg[y][x] in ("@", "+"):        # Spielfigur [auf Zielfeld]
          playerpos=(x, y)
        if pg[y][x] in ("$", "*"):        # Box [auf Zielfeld]
          pg_dynp.append(hlp.ppack(x, y))
      pg_stat.append(ln)
    return(pg_stat, pg_dynp, playerpos)

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import ppack [as 别名]
  # Liefert den kürzesten [freien] Weg von (cur_x, cur_y) nach
  # (x_dest, y_dest). Der Weg wird als Bewegungs-String
  # geliefert.
  # Pseudocode abgehacked von: http://de.wikipedia.org/wiki/Breitensuche
  def findBestWayTo(self, pgs, pgdp, (cur_x, cur_y), (x_dest, y_dest)):
    queue=deque([(cur_x, cur_y, "")])
    visited=[(cur_x, cur_y)]
    while queue:
      cur_x, cur_y, ks=queue.popleft()
      if (cur_x, cur_y)==(x_dest, y_dest):
        return(ks)
      for i in range(4):
        nx=cur_x+self.rp[i][0]
        ny=cur_y+self.rp[i][1]
        if (nx, ny) not in visited:
          if pgs[ny][nx]!="#" and hlp.ppack(nx, ny) not in pgdp:
            queue.append((nx, ny, ks+self.rt[i]))
            visited.append((nx, ny))
    return("")


  # ###########################################################
  # Bewegt die Box auf box_from nach box_to.
  # Liefert Status und (bei ==0) dem Bewegungsstring.
  #
  # Status:
  # 0 = gut
  # 1 = Start-Pos nicht Box (kommt nicht vor)
  # 2 = Ziel-Pos nicht frei
  # 4 = kein Weg zum Start
  # 5 = kein Weg von Start nach Ziel