Function GetPath

internal/mapper/mapper.path.go:196–270

(startRoomId int, endRoomId ...int)

}

func GetPath(startRoomId int, endRoomId ...int) ([]pathStep, error) {

	start := time.Now()
	defer func() {
		util.TrackTime(`mapper.GetPath()`, time.Since(start).Seconds())
	}()

	if len(endRoomId) == 0 {
		return []pathStep{}, fmt.Errorf("%d => %d (endRoom not found): %w", startRoomId, endRoomId, ErrPathNotFound)
	}

	startRoom := rooms.LoadRoom(startRoomId)
	if startRoom == nil {
		return []pathStep{}, fmt.Errorf("%d => %d (startRoom  not found): %w", startRoomId, endRoomId, ErrPathNotFound)
	}

	m := GetMapper(startRoom.RoomId)
	if m == nil {
		return []pathStep{}, fmt.Errorf("%d => %d (mapper not fond): %w", startRoomId, endRoomId, ErrPathNotFound)
	}

	cacheKey := pathCacheKey{}
	rNow := startRoomId
	finalPath := []pathStep{}
	for _, roomId := range endRoomId {

		if rNow == roomId { // Avoid repeating id's
			continue
		}

		cacheKey.startRoomId = rNow
		cacheKey.endRoomId = roomId

		if pCache, ok := pathCache.Get(cacheKey); ok {
			pathCacheHits.Add(1)

			if pCache.err != nil {
				return pCache.steps, fmt.Errorf("%d => %d: %w", rNow, roomId, pCache.err)
			}

			finalPath = append(finalPath, pCache.steps...)
			rNow = roomId
			continue
		}

		pathCacheMisses.Add(1)

		if !m.HasRoom(roomId) {
			err := fmt.Errorf("%d => %d (room not in mapper): %w", rNow, roomId, ErrPathNotFound)
			pathCache.Add(cacheKey, pathCacheValue{steps: nil, err: err})
			return []pathStep{}, err
		}

		p, err := m.findPath(rNow, roomId)
		if err != nil {
			pathCache.Add(cacheKey, pathCacheValue{steps: p, err: err})
			return []pathStep{}, fmt.Errorf("%d => %d: %w", rNow, roomId, ErrPathNotFound)
		}