Started implementing PDDL type parsing.
This commit is contained in:
parent
1c4c035acc
commit
a989f5f86e
57
include/plasp/pddl/ConsistencyException.h
Normal file
57
include/plasp/pddl/ConsistencyException.h
Normal file
@ -0,0 +1,57 @@
|
|||||||
|
#ifndef __PLASP__PDDL__CONSISTENCY_EXCEPTION_H
|
||||||
|
#define __PLASP__PDDL__CONSISTENCY_EXCEPTION_H
|
||||||
|
|
||||||
|
#include <exception>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
namespace plasp
|
||||||
|
{
|
||||||
|
namespace pddl
|
||||||
|
{
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// ConsistencyException
|
||||||
|
//
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
class ConsistencyException: public std::exception
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit ConsistencyException()
|
||||||
|
: ConsistencyException("Unspecified consistency error")
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
explicit ConsistencyException(const char *message)
|
||||||
|
: ConsistencyException(static_cast<std::string>(message))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
explicit ConsistencyException(const std::string &message)
|
||||||
|
: m_message{message}
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
~ConsistencyException() throw()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
const char *what() const throw()
|
||||||
|
{
|
||||||
|
if (m_message.empty())
|
||||||
|
return "Unspecified consistency error";
|
||||||
|
|
||||||
|
return m_message.c_str();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::string m_message;
|
||||||
|
};
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
@ -1,7 +1,10 @@
|
|||||||
#ifndef __PLASP__PDDL__DOMAIN_H
|
#ifndef __PLASP__PDDL__DOMAIN_H
|
||||||
#define __PLASP__PDDL__DOMAIN_H
|
#define __PLASP__PDDL__DOMAIN_H
|
||||||
|
|
||||||
|
#include <unordered_map>
|
||||||
|
|
||||||
#include <plasp/pddl/Requirement.h>
|
#include <plasp/pddl/Requirement.h>
|
||||||
|
#include <plasp/pddl/Type.h>
|
||||||
#include <plasp/utils/Parser.h>
|
#include <plasp/utils/Parser.h>
|
||||||
|
|
||||||
namespace plasp
|
namespace plasp
|
||||||
@ -20,9 +23,12 @@ class Domain
|
|||||||
public:
|
public:
|
||||||
static Domain fromPDDL(utils::Parser &parser);
|
static Domain fromPDDL(utils::Parser &parser);
|
||||||
|
|
||||||
|
using TypesHashMap = std::unordered_map<std::string, Type>;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
const std::string &name() const;
|
const std::string &name() const;
|
||||||
const Requirement::Types &requirements() const;
|
const Requirement::Types &requirements() const;
|
||||||
|
const TypesHashMap &types() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
Domain() = default;
|
Domain() = default;
|
||||||
@ -30,10 +36,16 @@ class Domain
|
|||||||
void parseSection(utils::Parser &parser);
|
void parseSection(utils::Parser &parser);
|
||||||
|
|
||||||
void parseRequirementsSection(utils::Parser &parser);
|
void parseRequirementsSection(utils::Parser &parser);
|
||||||
|
bool hasRequirement(Requirement::Type requirement) const;
|
||||||
void computeDerivedRequirements();
|
void computeDerivedRequirements();
|
||||||
|
|
||||||
|
void parseTypingSection(utils::Parser &parser);
|
||||||
|
|
||||||
|
void checkConsistency();
|
||||||
|
|
||||||
std::string m_name;
|
std::string m_name;
|
||||||
Requirement::Types m_requirements;
|
Requirement::Types m_requirements;
|
||||||
|
TypesHashMap m_types;
|
||||||
};
|
};
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
48
include/plasp/pddl/Type.h
Normal file
48
include/plasp/pddl/Type.h
Normal file
@ -0,0 +1,48 @@
|
|||||||
|
#ifndef __PLASP__PDDL__TYPE_H
|
||||||
|
#define __PLASP__PDDL__TYPE_H
|
||||||
|
|
||||||
|
#include <functional>
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include <plasp/utils/Parser.h>
|
||||||
|
|
||||||
|
namespace plasp
|
||||||
|
{
|
||||||
|
namespace pddl
|
||||||
|
{
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// Type
|
||||||
|
//
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
class Type
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Type(std::string name);
|
||||||
|
|
||||||
|
public:
|
||||||
|
void setDirty(bool isDirty = true);
|
||||||
|
bool isDirty() const;
|
||||||
|
|
||||||
|
const std::string &name() const;
|
||||||
|
|
||||||
|
void addParentType(const Type &parentType);
|
||||||
|
const std::vector<const Type *> &parentTypes() const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
bool m_isDirty;
|
||||||
|
|
||||||
|
std::string m_name;
|
||||||
|
|
||||||
|
std::vector<const Type *> m_parentTypes;
|
||||||
|
};
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
@ -26,6 +26,7 @@ class Parser
|
|||||||
|
|
||||||
char currentCharacter() const;
|
char currentCharacter() const;
|
||||||
void advance();
|
void advance();
|
||||||
|
bool advanceIf(char expectedCharacter);
|
||||||
bool atEndOfFile() const;
|
bool atEndOfFile() const;
|
||||||
|
|
||||||
template<typename Type>
|
template<typename Type>
|
||||||
@ -54,8 +55,6 @@ class Parser
|
|||||||
private:
|
private:
|
||||||
void checkStream() const;
|
void checkStream() const;
|
||||||
|
|
||||||
bool advanceIf(char expectedCharacter);
|
|
||||||
|
|
||||||
uint64_t parseIntegerBody();
|
uint64_t parseIntegerBody();
|
||||||
|
|
||||||
std::istream &m_istream;
|
std::istream &m_istream;
|
||||||
|
@ -2,6 +2,7 @@
|
|||||||
|
|
||||||
#include <algorithm>
|
#include <algorithm>
|
||||||
|
|
||||||
|
#include <plasp/pddl/ConsistencyException.h>
|
||||||
#include <plasp/pddl/Identifier.h>
|
#include <plasp/pddl/Identifier.h>
|
||||||
#include <plasp/utils/ParserException.h>
|
#include <plasp/utils/ParserException.h>
|
||||||
|
|
||||||
@ -38,6 +39,8 @@ Domain Domain::fromPDDL(utils::Parser &parser)
|
|||||||
|
|
||||||
domain.computeDerivedRequirements();
|
domain.computeDerivedRequirements();
|
||||||
|
|
||||||
|
domain.checkConsistency();
|
||||||
|
|
||||||
return domain;
|
return domain;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -57,6 +60,13 @@ const Requirement::Types &Domain::requirements() const
|
|||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
const Domain::TypesHashMap &Domain::types() const
|
||||||
|
{
|
||||||
|
return m_types;
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
void Domain::parseSection(utils::Parser &parser)
|
void Domain::parseSection(utils::Parser &parser)
|
||||||
{
|
{
|
||||||
parser.expect<std::string>("(:");
|
parser.expect<std::string>("(:");
|
||||||
@ -90,7 +100,7 @@ void Domain::parseSection(utils::Parser &parser)
|
|||||||
if (sectionIdentifier == "requirements")
|
if (sectionIdentifier == "requirements")
|
||||||
parseRequirementsSection(parser);
|
parseRequirementsSection(parser);
|
||||||
else if (sectionIdentifier == "types")
|
else if (sectionIdentifier == "types")
|
||||||
skipSection();
|
parseTypingSection(parser);
|
||||||
else if (sectionIdentifier == "constants")
|
else if (sectionIdentifier == "constants")
|
||||||
skipSection();
|
skipSection();
|
||||||
else if (sectionIdentifier == "predicates")
|
else if (sectionIdentifier == "predicates")
|
||||||
@ -128,16 +138,17 @@ void Domain::parseRequirementsSection(utils::Parser &parser)
|
|||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
bool Domain::hasRequirement(Requirement::Type requirement) const
|
||||||
|
{
|
||||||
|
const auto match = std::find(m_requirements.cbegin(), m_requirements.cend(), requirement);
|
||||||
|
|
||||||
|
return match != m_requirements.cend();
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
void Domain::computeDerivedRequirements()
|
void Domain::computeDerivedRequirements()
|
||||||
{
|
{
|
||||||
const auto hasRequirement =
|
|
||||||
[&](const auto requirement)
|
|
||||||
{
|
|
||||||
const auto match = std::find(m_requirements.cbegin(), m_requirements.cend(), requirement);
|
|
||||||
|
|
||||||
return match != m_requirements.cend();
|
|
||||||
};
|
|
||||||
|
|
||||||
const auto addRequirementUnique =
|
const auto addRequirementUnique =
|
||||||
[&](const auto requirement)
|
[&](const auto requirement)
|
||||||
{
|
{
|
||||||
@ -180,5 +191,68 @@ void Domain::computeDerivedRequirements()
|
|||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
void Domain::parseTypingSection(utils::Parser &parser)
|
||||||
|
{
|
||||||
|
// Parses a single type identifier
|
||||||
|
const auto parseType =
|
||||||
|
[&]() -> auto &
|
||||||
|
{
|
||||||
|
parser.skipWhiteSpace();
|
||||||
|
|
||||||
|
const auto typeName = parser.parseIdentifier(isIdentifier);
|
||||||
|
const auto insertionResult = m_types.emplace(std::make_pair(typeName, Type(typeName)));
|
||||||
|
auto &type = insertionResult.first->second;
|
||||||
|
|
||||||
|
// Flag type for potentially upcoming parent type declaration
|
||||||
|
type.setDirty();
|
||||||
|
|
||||||
|
parser.skipWhiteSpace();
|
||||||
|
|
||||||
|
return type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Parses a type and potentially its parent type
|
||||||
|
while (parser.currentCharacter() != ')')
|
||||||
|
{
|
||||||
|
parseType();
|
||||||
|
|
||||||
|
// Check for type inheritance
|
||||||
|
if (!parser.advanceIf('-'))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// If existing, parse parent type
|
||||||
|
auto &parentType = parseType();
|
||||||
|
|
||||||
|
parentType.setDirty(false);
|
||||||
|
|
||||||
|
// Assign parent type to all types that were previously flagged
|
||||||
|
std::for_each(m_types.begin(), m_types.end(),
|
||||||
|
[&](auto &childType)
|
||||||
|
{
|
||||||
|
if (!childType.second.isDirty())
|
||||||
|
return;
|
||||||
|
|
||||||
|
childType.second.addParentType(parentType);
|
||||||
|
childType.second.setDirty(false);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
parser.expect<std::string>(")");
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
void Domain::checkConsistency()
|
||||||
|
{
|
||||||
|
if (!m_types.empty() && !hasRequirement(Requirement::Type::Typing))
|
||||||
|
{
|
||||||
|
throw ConsistencyException("Domain contains typing information but does not declare typing requirement");
|
||||||
|
|
||||||
|
m_requirements.push_back(Requirement::Type::Typing);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
58
src/plasp/pddl/Type.cpp
Normal file
58
src/plasp/pddl/Type.cpp
Normal file
@ -0,0 +1,58 @@
|
|||||||
|
#include <plasp/pddl/Type.h>
|
||||||
|
|
||||||
|
namespace plasp
|
||||||
|
{
|
||||||
|
namespace pddl
|
||||||
|
{
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// Type
|
||||||
|
//
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
Type::Type(std::string name)
|
||||||
|
: m_isDirty{false},
|
||||||
|
m_name{name}
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
void Type::setDirty(bool isDirty)
|
||||||
|
{
|
||||||
|
m_isDirty = isDirty;
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
bool Type::isDirty() const
|
||||||
|
{
|
||||||
|
return m_isDirty;
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
const std::string &Type::name() const
|
||||||
|
{
|
||||||
|
return m_name;
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
void Type::addParentType(const Type &parentType)
|
||||||
|
{
|
||||||
|
m_parentTypes.emplace_back(&parentType);
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
const std::vector<const Type *> &Type::parentTypes() const
|
||||||
|
{
|
||||||
|
return m_parentTypes;
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
@ -13,7 +13,8 @@ class PDDLParserTests : public ::testing::Test
|
|||||||
{
|
{
|
||||||
protected:
|
protected:
|
||||||
PDDLParserTests()
|
PDDLParserTests()
|
||||||
: m_blocksworldDomainFile(readFile("data/blocksworld-domain.pddl"))
|
: m_blocksworldDomainFile(readFile("data/blocksworld-domain.pddl")),
|
||||||
|
m_storageDomainFile(readFile("data/storage-domain.pddl"))
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -32,11 +33,12 @@ class PDDLParserTests : public ::testing::Test
|
|||||||
}
|
}
|
||||||
|
|
||||||
std::stringstream m_blocksworldDomainFile;
|
std::stringstream m_blocksworldDomainFile;
|
||||||
|
std::stringstream m_storageDomainFile;
|
||||||
};
|
};
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
TEST_F(PDDLParserTests, ParseValidPDDLFile)
|
TEST_F(PDDLParserTests, ParseBlocksWorldDomain)
|
||||||
{
|
{
|
||||||
try
|
try
|
||||||
{
|
{
|
||||||
@ -46,9 +48,62 @@ TEST_F(PDDLParserTests, ParseValidPDDLFile)
|
|||||||
|
|
||||||
const auto &domain = description.domain();
|
const auto &domain = description.domain();
|
||||||
|
|
||||||
|
ASSERT_EQ(domain.name(), "BLOCKS");
|
||||||
|
|
||||||
ASSERT_EQ(domain.requirements().size(), 2u);
|
ASSERT_EQ(domain.requirements().size(), 2u);
|
||||||
ASSERT_EQ(domain.requirements()[0], plasp::pddl::Requirement::Type::STRIPS);
|
ASSERT_EQ(domain.requirements()[0], plasp::pddl::Requirement::Type::STRIPS);
|
||||||
ASSERT_EQ(domain.requirements()[1], plasp::pddl::Requirement::Type::Typing);
|
ASSERT_EQ(domain.requirements()[1], plasp::pddl::Requirement::Type::Typing);
|
||||||
|
|
||||||
|
ASSERT_EQ(domain.types().size(), 1u);
|
||||||
|
|
||||||
|
const auto blockType = domain.types().find("block");
|
||||||
|
ASSERT_NE(blockType, domain.types().cend());
|
||||||
|
|
||||||
|
ASSERT_EQ(blockType->second.name(), "block");
|
||||||
|
ASSERT_EQ(blockType->second.parentTypes().size(), 0u);
|
||||||
|
}
|
||||||
|
catch (const std::exception &e)
|
||||||
|
{
|
||||||
|
FAIL() << e.what();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
TEST_F(PDDLParserTests, ParseStorageDomain)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
const auto description = plasp::pddl::Description::fromStream(m_storageDomainFile);
|
||||||
|
|
||||||
|
ASSERT_NO_THROW(description.domain());
|
||||||
|
|
||||||
|
const auto &domain = description.domain();
|
||||||
|
|
||||||
|
ASSERT_EQ(domain.name(), "Storage-Propositional");
|
||||||
|
|
||||||
|
ASSERT_EQ(domain.requirements().size(), 1u);
|
||||||
|
ASSERT_EQ(domain.requirements()[0], plasp::pddl::Requirement::Type::Typing);
|
||||||
|
|
||||||
|
const auto area = domain.types().find("area");
|
||||||
|
ASSERT_NE(area, domain.types().cend());
|
||||||
|
const auto hoist = domain.types().find("hoist");
|
||||||
|
ASSERT_NE(hoist, domain.types().cend());
|
||||||
|
const auto object = domain.types().find("object");
|
||||||
|
ASSERT_NE(object, domain.types().cend());
|
||||||
|
const auto storearea = domain.types().find("storearea");
|
||||||
|
ASSERT_NE(storearea, domain.types().cend());
|
||||||
|
const auto surface= domain.types().find("surface");
|
||||||
|
ASSERT_NE(surface, domain.types().cend());
|
||||||
|
|
||||||
|
const auto &hoistParents = hoist->second.parentTypes();
|
||||||
|
ASSERT_EQ(hoistParents.size(), 1u);
|
||||||
|
ASSERT_TRUE(std::find(hoistParents.cbegin(), hoistParents.cend(), &object->second) != hoistParents.cend());
|
||||||
|
|
||||||
|
const auto &areaParents = area->second.parentTypes();
|
||||||
|
ASSERT_EQ(areaParents.size(), 2u);
|
||||||
|
ASSERT_TRUE(std::find(areaParents.cbegin(), areaParents.cend(), &object->second) != areaParents.cend());
|
||||||
|
ASSERT_TRUE(std::find(areaParents.cbegin(), areaParents.cend(), &surface->second) != areaParents.cend());
|
||||||
}
|
}
|
||||||
catch (const std::exception &e)
|
catch (const std::exception &e)
|
||||||
{
|
{
|
||||||
|
46
tests/data/storage-domain.pddl
Normal file
46
tests/data/storage-domain.pddl
Normal file
@ -0,0 +1,46 @@
|
|||||||
|
(define (domain Storage-Propositional)
|
||||||
|
(:requirements :typing)
|
||||||
|
(:types hoist surface place area - object
|
||||||
|
container depot - place
|
||||||
|
storearea transitarea - area
|
||||||
|
area crate - surface)
|
||||||
|
|
||||||
|
(:predicates (clear ?s - storearea)
|
||||||
|
(in ?x - (either storearea crate) ?p - place)
|
||||||
|
(available ?h - hoist)
|
||||||
|
(lifting ?h - hoist ?c - crate)
|
||||||
|
(at ?h - hoist ?a - area)
|
||||||
|
(on ?c - crate ?s - storearea)
|
||||||
|
(connected ?a1 ?a2 - area)
|
||||||
|
(compatible ?c1 ?c2 - crate))
|
||||||
|
|
||||||
|
(:action lift
|
||||||
|
:parameters (?h - hoist ?c - crate ?a1 - storearea ?a2 - area ?p - place)
|
||||||
|
:precondition (and (connected ?a1 ?a2) (at ?h ?a2) (available ?h)
|
||||||
|
(on ?c ?a1) (in ?a1 ?p))
|
||||||
|
:effect (and (not (on ?c ?a1)) (clear ?a1)
|
||||||
|
(not (available ?h)) (lifting ?h ?c) (not (in ?c ?p))))
|
||||||
|
|
||||||
|
(:action drop
|
||||||
|
:parameters (?h - hoist ?c - crate ?a1 - storearea ?a2 - area ?p - place)
|
||||||
|
:precondition (and (connected ?a1 ?a2) (at ?h ?a2) (lifting ?h ?c)
|
||||||
|
(clear ?a1) (in ?a1 ?p))
|
||||||
|
:effect (and (not (lifting ?h ?c)) (available ?h)
|
||||||
|
(not (clear ?a1)) (on ?c ?a1) (in ?c ?p)))
|
||||||
|
|
||||||
|
(:action move
|
||||||
|
:parameters (?h - hoist ?from ?to - storearea)
|
||||||
|
:precondition (and (at ?h ?from) (clear ?to) (connected ?from ?to))
|
||||||
|
:effect (and (not (at ?h ?from)) (at ?h ?to) (not (clear ?to)) (clear ?from)))
|
||||||
|
|
||||||
|
(:action go-out
|
||||||
|
:parameters (?h - hoist ?from - storearea ?to - transitarea)
|
||||||
|
:precondition (and (at ?h ?from) (connected ?from ?to))
|
||||||
|
:effect (and (not (at ?h ?from)) (at ?h ?to) (clear ?from)))
|
||||||
|
|
||||||
|
(:action go-in
|
||||||
|
:parameters (?h - hoist ?from - transitarea ?to - storearea)
|
||||||
|
:precondition (and (at ?h ?from) (connected ?from ?to) (clear ?to))
|
||||||
|
:effect (and (not (at ?h ?from)) (at ?h ?to) (not (clear ?to))))
|
||||||
|
)
|
||||||
|
|
Reference in New Issue
Block a user