def draw (gp, display) :
#draw the goal and score
Goal.draw(display)
ScoreBoard.drawScore(gp.score, display)
#create the soccer team and ball nodes if first draw or just draw else
if gp.playersNodes is None:
gp.setPlayers(SoccerPlayer.drawTeam(display))
else:
for player in gp.playersNodes:
player.draw(display)
if gp.ballNode is None:
gp.setBall(Ball.Ball())
gp.ballNode.draw(display)
else:
gp.ballNode.draw(display)
def events(self):
keys = pygame.key.get_pressed()
for e in pygame.event.get():
if e.type == pygame.QUIT:
pygame.quit()
exit()
if e.type == pygame.KEYDOWN:
if e.key == pygame.K_w:
self.player.jump()
if e.type == pygame.KEYUP:
if e.key == pygame.K_w:
self.player.jump_cut()
if (len(self.goals) == 0
or (pygame.time.get_ticks() - self.time) / 1000 > 10):
self.time = pygame.time.get_ticks()
Goal(self, random.choice(self.positions))
if (pygame.time.get_ticks() - self.timeTimer) / 1000 > .5:
self.timeTimer = pygame.time.get_ticks()
self.timer -= .5
if (self.timer < 0):
self.gameOver = True
self.player.events()
def organizer():
return_error = lambda local_error: render_template('organizer.html',
goals=goals.goal_list,
needs=needs.goal_list,
error=local_error)
update_organizer = lambda: render_template(
'organizer.html', needs=needs.goal_list, goals=goals.goal_list)
if request.method == 'POST':
if not ('goal_name' in request.form and 'goal_cost' in request.form
and 'goal_priority' in request.form):
return return_error(
'Enter your goal, cost, and how important it is to you!')
else:
session['goal_name'] = request.form['goal_name']
session['goal_cost'] = request.form['goal_cost']
session['goal_priority'] = request.form['goal_priority']
#Adds New Goal to Goals
goals.append(
gl.Goal(int(request.form['goal_cost']),
-1,
-1,
request.form['goal_name'],
int(request.form['goal_priority']),
i=None))
#Updates Values that need to be updated
goals.set_indices()
goals.update()
return update_organizer()
return render_template('organizer.html')
def __init__(self):
SceneBase.__init__(self)
playerimage = pygame.transform.scale(pygame.image.load("Images/player.png"), (30, 30))
# creates the Player character in the location 20, 20
self.player = Player.Player(30, 30, playerimage)
blueParticle = pygame.image.load("Images/particle_blue.png")
redParticle = pygame.image.load("Images/particle_red.png")
# Defines the starting positions of the first two Particles for level 1 of the game
self.particle1 = Particle.Particle(100, 100, False, None, redParticle, False)
self.particle2 = Particle.Particle(100, 200, True, self.particle1, blueParticle, False) # Particle 2 is entangled to Particle one
# Defines the position for the first goal for level 1 of the game
self.goal = Goal.Goal(400, 400)
# NOTE: Negative numbers in wall declarations ruin collision detection
self.leftWall = Wall.Wall(0, 0, 20, 600)
self.rightWall = Wall.Wall(780, 0, 20, 600)
self.topWall = Wall.Wall(0, 0, 800, 20)
self.bottomWall = Wall.Wall(0, 580, 800, 20)
self.door = Door.Door(760, 300, 20, 100)
self.walls=[self.leftWall,self.rightWall,self.bottomWall,self.topWall]
# Defines the objects that the Player character cannot pass through
self.entities = [self.player,self.particle1, self.particle2, self.leftWall, self.rightWall, self.topWall, self.bottomWall]
self.particles=[self.particle1,self.particle2]
self.startTime=int(round(time.time()))
pygame.mixer.music.load('A Strange Charm.wav')
pygame.mixer.music.play(-1)
def __init__(self, configuration):
super().__init__()
# There is only one agent in this setting
self.agent_id = 0
# Dialogue statistics
self.dialogue_episode = 0
self.dialogue_turn = 0
self.num_successful_dialogues = 0
self.num_task_success = 0
self.cumulative_rewards = 0
self.total_dialogue_turns = 0
self.minibatch_length = 50
self.train_interval = 10
self.num_batches_per_epoch = 10
self.SAVE_LOG = True
# The dialogue will terminate after MAX_TURNS (this agent will issue
# a bye() dialogue act.
self.MAX_TURNS = 15
self.dialogue_turn = -1
self.dialogue_manager = None
self.user_model = None
self.agent_goal = None
self.goal_generator = None
self.prev_turnstate = TurnState()
self.curr_state = None
self.recorder = DialogueEpisodeRecorder()
# TODO: Handle this properly - get reward function type from config
self.reward_func = SlotFillingReward()
self.ontology, self.database = build_domain_settings(
configuration["DIALOGUE"])
self.user_simulator = AgendaBasedUS(
goal_generator=Goal.GoalGenerator(self.ontology, self.database),
error_model=ErrorModel(
self.ontology,
slot_confuse_prob=0.0,
op_confuse_prob=0.0,
value_confuse_prob=0.0,
),
)
self.dialogue_manager = DialogueManager.DialogueManager(
configuration,
self.ontology,
self.database,
self.agent_id,
"system",
configuration["AGENT_0"]["DM"]["policy"],
)
def getGoal(goal_msg):
"""
Create and get list of Goal obj \n
Args:
goal_msg: msg of goal
Return: list of goal and positions
goal_list: list of Goal obj
target_pos: positions of goals
"""
goal_list = []
target_pos = []
for g in goal_msg.goal:
grasp_points = []
id = g.id
center = PoseMsgToMatrix(g.center)
#tmp_c = np.array([g.center.position.x, g.center.position.y, g.center.position.z])
tmp_c = np.array([
g.grasping_points[0].pose.position.x,
g.grasping_points[0].pose.position.y,
g.grasping_points[0].pose.position.z
])
target_pos.append(tmp_c)
for grasp in g.grasping_points:
grasp_points.append(grasp)
goal = Goal.Goal(id, center, grasp_points)
goal_list.append(goal)
return goal_list, target_pos
def makeGoals():
goal = Goal(1, 15)
goal.params['numRuns'] = 3
goal.params['totalDuration'] = 60
goals_list.append(goal)
goal = Goal(2, 20)
goal.params['runAvgSpeed'] = 10
goal.params['totalDistance'] = 30
goals_list.append(goal)
goal = Goal(3, 30)
goal.params['totalDistance'] = 60
goal.params['runMinSpeed'] = 8
goals_list.append(goal)
def createNewGoal(self, wherex, wherey, screenCoordinates=1):
self.fromClass = None
self.toClass = None
# try the global constraints...
res = self.ASGroot.preCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
new_semantic_obj = Goal(self)
res = new_semantic_obj.preCondition(ASGNode.CREATE)
if res: return self.constraintViolation(res)
new_semantic_obj.preAction(ASGNode.CREATE)
ne = len(self.ASGroot.listNodes["Goal"])
if new_semantic_obj.keyword_:
new_semantic_obj.keyword_.setValue(
new_semantic_obj.keyword_.toString() + str(ne))
if screenCoordinates:
new_obj = graph_Goal(self.UMLmodel.canvasx(wherex),
self.UMLmodel.canvasy(wherey), new_semantic_obj)
else: # already in canvas coordinates
new_obj = graph_Goal(wherex, wherey, new_semantic_obj)
new_obj.DrawObject(self.UMLmodel, self.editGGLabel)
self.UMLmodel.addtag_withtag("Goal", new_obj.tag)
new_semantic_obj.graphObject_ = new_obj
self.ASGroot.addNode(new_semantic_obj)
res = self.ASGroot.postCondition(ASG.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
res = new_semantic_obj.postCondition(ASGNode.CREATE)
if res:
self.constraintViolation(res)
self.mode = self.IDLEMODE
return
new_semantic_obj.postAction(ASGNode.CREATE)
self.mode = self.IDLEMODE
if self.editGGLabel:
self.statusbar.event(StatusBar.TRANSFORMATION, StatusBar.CREATE)
else:
self.statusbar.event(StatusBar.MODEL, StatusBar.CREATE)
return new_semantic_obj
def __init__(self, player, clock):
SceneBase.__init__(self)
# creates the Player character in the location 20, 20
self.player = player
player.x = 30
player.y = 30
# Defines the starting positions of the first two Particles for level 3 of the game
self.particle1 = Particle.Particle(90, 360, False, None, greenParticle,
False)
self.particle2 = Particle.Particle(
90, 80, True, self.particle1, greenParticle,
False) # Particle 2 is entangled to Particle one
# Defines the position for the first goal for level 3 of the game
self.goal = Goal.Goal(720, 530)
self.door = Door.Door(760, 100, 20, 100)
# NOTE: Negative numbers in wall declarations ruin collision detection
self.leftWall = Wall.Wall(0, 0, 20, 600)
self.rightWall = Wall.Wall(780, 0, 20, 600)
self.topWall = Wall.Wall(0, 0, 800, 20)
self.bottomWall = Wall.Wall(0, 580, 800, 20)
self.centerWallObstacle = Wall.Wall(20, 290, 780, 30)
self.lowerWallObstacle = Wall.Wall(20, 390, 280, 20)
self.middleWallObstacle = Wall.Wall(380, 300, 20, 180)
self.rightWallObstacleOne = Wall.Wall(500, 450, 20, 130)
self.rightWallObstacleTwo = Wall.Wall(580, 360, 200, 20)
self.walls = [
self.leftWall, self.rightWall, self.bottomWall, self.topWall,
self.centerWallObstacle, self.lowerWallObstacle,
self.middleWallObstacle, self.rightWallObstacleOne,
self.rightWallObstacleTwo
]
# Defines the objects that the Player character cannot pass through
self.entities = [
self.player, self.particle1, self.particle2, self.leftWall,
self.rightWall, self.topWall, self.bottomWall,
self.centerWallObstacle, self.lowerWallObstacle,
self.middleWallObstacle, self.rightWallObstacleOne,
self.rightWallObstacleTwo
]
self.particles = [self.particle1, self.particle2]
self.startTime = clock
def collisionCheck (pm, gp):
#break if players not set yet
if gp.playersNodes is None:
return
#check the node rects for collision
for player in gp.playersNodes :
if player.collidesWithBall(gp.ballNode, Ball.radius):
# print("game lost")
endLevel(False, pm, gp)
#check if player scored
if Goal.collidesWithBall(gp.ballNode, Ball.radius):
print("game won")
endLevel(True, pm, gp)
else: #check for user colliding with walls
if gp.ballNode.position[1] < Ball.radius \
or gp.ballNode.position[1] > GameProperties.size[1] - Ball.radius \
or gp.ballNode.position[0] < Ball.radius \
or gp.ballNode.position[0] > GameProperties.size[0] + Ball.radius:
endLevel(False, pm, gp)
def create(self, platforms, buttons, spikes, goals, clones):
# Adds clones that aren't part of the spawn point as platforms
clone_list = pygame.sprite.Group()
for platform in clones:
block = Clone.Clone(platform[4], platform[5])
block.rect.x = platform[2]
block.rect.y = platform[3]
clone_list.add(block)
pygame.sprite.spritecollide(self.player, clone_list, True)
for clone in clone_list:
self.platform_list.add(clone)
# Go through the array above and add platforms
for platform in platforms:
block = plat.Platform(platform[0], platform[1])
block.rect.x = platform[2]
block.rect.y = platform[3]
self.platform_list.add(block)
for button in buttons:
if platform == button[1]:
but = bt.Button(self.player, clone_list, block, self)
but.rect.x = button[0][0]
but.rect.y = button[0][1]
self.button_list.add(but)
for spike in spikes:
block = sp.Spike(spike[2])
block.rect.x = spike[0]
block.rect.y = spike[1]
self.spike_list.add(block)
for goal in goals:
block = gl.Goal(goal[0], goal[1])
block.rect.x = goal[2]
block.rect.y = goal[3]
self.goal_list.add(block)
mPR, mPS)
gpsData = GPS.readGPS()
Motor.motor(mPL, mPR, 0.1, 1)
print("Running Phase Finished")
IM920.Send("P7F")
# ------------------- GoalDetection Phase ------------------- #
if (phaseChk <= 8):
Other.saveLog(phaseLog, "8", "GoalDetection Phase Started",
time.time() - t_start)
print("Goal Detection Phase Started")
IM920.Send("P8S")
H_min = 200
H_max = 10
S_thd = 120
goal = Goal.Togoal(photopath, H_min, H_max, S_thd)
while goal[0] != 0:
gpsdata = GPS.readGPS()
goal = Goal.Togoal(photopath, H_min, H_max, S_thd)
print("goal is", goal)
Other.saveLog(goalDetectionLog,
time.time() - t_start, gpsData, goal)
Other.saveLog(captureLog, time.time() - t_start, goal)
print("Goal Detection Phase Finished")
IM920.Send("P8F")
print("Program Finished")
IM920.Send("P10")
Other.saveLog(phaseLog, "10", "Program Finished",
time.time() - t_start)
close()
# Evergreen Variables
###########################################
game_state = STATE.END
game_timer = Timer(TIMER_TYPES.MATCH)
match_number = -1
alliances = {ALLIANCE_COLOR.GOLD: None, ALLIANCE_COLOR.BLUE: None}
###########################################
# Game Specific Variables
###########################################
goals = {
GOAL.A : Goal(GOAL.A, CONSTANTS.GOAL_LOW_VALUE, CONSTANTS.GOAL_LOW_COST),
GOAL.B : Goal(GOAL.B, CONSTANTS.GOAL_MED_VALUE, CONSTANTS.GOAL_MED_COST),
GOAL.C : Goal(GOAL.C, CONSTANTS.GOAL_HIGH_VALUE, CONSTANTS.GOAL_HIGH_COST),
GOAL.D : Goal(GOAL.D, CONSTANTS.GOAL_MED_VALUE, CONSTANTS.GOAL_MED_COST),
GOAL.E : Goal(GOAL.E, CONSTANTS.GOAL_LOW_VALUE, CONSTANTS.GOAL_LOW_COST),
GOAL.BLUE : Goal(GOAL.BLUE, CONSTANTS.GOAL_BASE_VALUE, 0),
GOAL.GOLD : Goal(GOAL.GOLD, CONSTANTS.GOAL_BASE_VALUE, 0),
}
rfid_pool = None
curr_rfids = None
powerup_functions = [POWERUP_TYPES.ZERO_X,
POWERUP_TYPES.TWO_X,
POWERUP_TYPES.STEAL,
POWERUP_TYPES.ZERO_X,
POWERUP_TYPES.TWO_X,
def __init__(self, parent):
GGrule.__init__(self, 15)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.LHS.merge(ASG_GenericGraph(parent))
self.obj1677 = product(parent)
self.obj1677.preAction(self.LHS.CREATE)
self.obj1677.isGraphObjectVisual = True
if (hasattr(self.obj1677, '_setHierarchicalLink')):
self.obj1677._setHierarchicalLink(False)
# MaxFlow
self.obj1677.MaxFlow.setNone()
# price
self.obj1677.price.setValue(0)
# Name
self.obj1677.Name.setValue('')
self.obj1677.Name.setNone()
# ReqFlow
self.obj1677.ReqFlow.setNone()
self.obj1677.GGLabel.setValue(5)
self.obj1677.graphClass_ = graph_product
if parent.genGraphics:
new_obj = graph_product(280.0, 220.0, self.obj1677)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1677.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1677)
self.obj1677.postAction(self.LHS.CREATE)
self.obj1678 = metarial(parent)
self.obj1678.preAction(self.LHS.CREATE)
self.obj1678.isGraphObjectVisual = True
if (hasattr(self.obj1678, '_setHierarchicalLink')):
self.obj1678._setHierarchicalLink(False)
# MaxFlow
self.obj1678.MaxFlow.setNone()
# price
self.obj1678.price.setValue(0)
# Name
self.obj1678.Name.setValue('')
self.obj1678.Name.setNone()
# ReqFlow
self.obj1678.ReqFlow.setNone()
self.obj1678.GGLabel.setValue(3)
self.obj1678.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(320.0, 40.0, self.obj1678)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1678.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1678)
self.obj1678.postAction(self.LHS.CREATE)
self.obj1679 = Goal(parent)
self.obj1679.preAction(self.LHS.CREATE)
self.obj1679.isGraphObjectVisual = True
if (hasattr(self.obj1679, '_setHierarchicalLink')):
self.obj1679._setHierarchicalLink(False)
# name
self.obj1679.name.setValue('')
self.obj1679.name.setNone()
self.obj1679.GGLabel.setValue(2)
self.obj1679.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(180.0, 60.0, self.obj1679)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1679.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1679)
self.obj1679.postAction(self.LHS.CREATE)
self.obj1680 = GenericGraphEdge(parent)
self.obj1680.preAction(self.LHS.CREATE)
self.obj1680.isGraphObjectVisual = True
if (hasattr(self.obj1680, '_setHierarchicalLink')):
self.obj1680._setHierarchicalLink(False)
self.obj1680.GGLabel.setValue(4)
self.obj1680.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(264.5, 71.5, self.obj1680)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1680.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1680)
self.obj1680.postAction(self.LHS.CREATE)
self.obj1679.out_connections_.append(self.obj1680)
self.obj1680.in_connections_.append(self.obj1679)
self.obj1679.graphObject_.pendingConnections.append(
(self.obj1679.graphObject_.tag, self.obj1680.graphObject_.tag,
[203.0, 61.0, 264.5, 71.5], 0, True))
self.obj1680.out_connections_.append(self.obj1678)
self.obj1678.in_connections_.append(self.obj1680)
self.obj1680.graphObject_.pendingConnections.append(
(self.obj1680.graphObject_.tag, self.obj1678.graphObject_.tag,
[326.0, 82.0, 264.5, 71.5], 0, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1684 = product(parent)
self.obj1684.preAction(self.RHS.CREATE)
self.obj1684.isGraphObjectVisual = True
if (hasattr(self.obj1684, '_setHierarchicalLink')):
self.obj1684._setHierarchicalLink(False)
# MaxFlow
self.obj1684.MaxFlow.setNone()
# price
self.obj1684.price.setValue(0)
# Name
self.obj1684.Name.setValue('')
self.obj1684.Name.setNone()
# ReqFlow
self.obj1684.ReqFlow.setNone()
self.obj1684.GGLabel.setValue(5)
self.obj1684.graphClass_ = graph_product
if parent.genGraphics:
new_obj = graph_product(280.0, 220.0, self.obj1684)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1684.graphObject_ = new_obj
self.obj16840 = AttrCalc()
self.obj16840.Copy = ATOM3Boolean()
self.obj16840.Copy.setValue(('Copy from LHS', 1))
self.obj16840.Copy.config = 0
self.obj16840.Specify = ATOM3Constraint()
self.obj16840.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1684.GGset2Any['MaxFlow'] = self.obj16840
self.obj16841 = AttrCalc()
self.obj16841.Copy = ATOM3Boolean()
self.obj16841.Copy.setValue(('Copy from LHS', 1))
self.obj16841.Copy.config = 0
self.obj16841.Specify = ATOM3Constraint()
self.obj16841.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1684.GGset2Any['Name'] = self.obj16841
self.obj16842 = AttrCalc()
self.obj16842.Copy = ATOM3Boolean()
self.obj16842.Copy.setValue(('Copy from LHS', 1))
self.obj16842.Copy.config = 0
self.obj16842.Specify = ATOM3Constraint()
self.obj16842.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1684.GGset2Any['ReqFlow'] = self.obj16842
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1684)
self.obj1684.postAction(self.RHS.CREATE)
self.obj1685 = metarial(parent)
self.obj1685.preAction(self.RHS.CREATE)
self.obj1685.isGraphObjectVisual = True
if (hasattr(self.obj1685, '_setHierarchicalLink')):
self.obj1685._setHierarchicalLink(False)
# MaxFlow
self.obj1685.MaxFlow.setNone()
# price
self.obj1685.price.setValue(0)
# Name
self.obj1685.Name.setValue('')
self.obj1685.Name.setNone()
# ReqFlow
self.obj1685.ReqFlow.setNone()
self.obj1685.GGLabel.setValue(3)
self.obj1685.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(320.0, 40.0, self.obj1685)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1685.graphObject_ = new_obj
self.obj16850 = AttrCalc()
self.obj16850.Copy = ATOM3Boolean()
self.obj16850.Copy.setValue(('Copy from LHS', 1))
self.obj16850.Copy.config = 0
self.obj16850.Specify = ATOM3Constraint()
self.obj16850.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1685.GGset2Any['MaxFlow'] = self.obj16850
self.obj16851 = AttrCalc()
self.obj16851.Copy = ATOM3Boolean()
self.obj16851.Copy.setValue(('Copy from LHS', 1))
self.obj16851.Copy.config = 0
self.obj16851.Specify = ATOM3Constraint()
self.obj16851.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1685.GGset2Any['Name'] = self.obj16851
self.obj16852 = AttrCalc()
self.obj16852.Copy = ATOM3Boolean()
self.obj16852.Copy.setValue(('Copy from LHS', 1))
self.obj16852.Copy.config = 0
self.obj16852.Specify = ATOM3Constraint()
self.obj16852.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1685.GGset2Any['ReqFlow'] = self.obj16852
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1685)
self.obj1685.postAction(self.RHS.CREATE)
self.obj1686 = operatingUnit(parent)
self.obj1686.preAction(self.RHS.CREATE)
self.obj1686.isGraphObjectVisual = True
if (hasattr(self.obj1686, '_setHierarchicalLink')):
self.obj1686._setHierarchicalLink(False)
# OperCostProp
self.obj1686.OperCostProp.setValue(1.0)
# name
self.obj1686.name.setValue('')
self.obj1686.name.setNone()
# OperCostFix
self.obj1686.OperCostFix.setValue(2.0)
self.obj1686.GGLabel.setValue(7)
self.obj1686.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(320.0, 140.0, self.obj1686)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1686.graphObject_ = new_obj
self.obj16860 = AttrCalc()
self.obj16860.Copy = ATOM3Boolean()
self.obj16860.Copy.setValue(('Copy from LHS', 0))
self.obj16860.Copy.config = 0
self.obj16860.Specify = ATOM3Constraint()
self.obj16860.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1686.GGset2Any['OperCostProp'] = self.obj16860
self.obj16861 = AttrCalc()
self.obj16861.Copy = ATOM3Boolean()
self.obj16861.Copy.setValue(('Copy from LHS', 0))
self.obj16861.Copy.config = 0
self.obj16861.Specify = ATOM3Constraint()
self.obj16861.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
'return self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' OAF\'\n'
))
self.obj1686.GGset2Any['name'] = self.obj16861
self.obj16862 = AttrCalc()
self.obj16862.Copy = ATOM3Boolean()
self.obj16862.Copy.setValue(('Copy from LHS', 0))
self.obj16862.Copy.config = 0
self.obj16862.Specify = ATOM3Constraint()
self.obj16862.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1686.GGset2Any['OperCostFix'] = self.obj16862
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1686)
self.obj1686.postAction(self.RHS.CREATE)
self.obj1687 = intoProduct(parent)
self.obj1687.preAction(self.RHS.CREATE)
self.obj1687.isGraphObjectVisual = True
if (hasattr(self.obj1687, '_setHierarchicalLink')):
self.obj1687._setHierarchicalLink(False)
# rate
self.obj1687.rate.setValue(1.0)
self.obj1687.GGLabel.setValue(9)
self.obj1687.graphClass_ = graph_intoProduct
if parent.genGraphics:
new_obj = graph_intoProduct(322.0, 179.0, self.obj1687)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1687.graphObject_ = new_obj
self.obj16870 = AttrCalc()
self.obj16870.Copy = ATOM3Boolean()
self.obj16870.Copy.setValue(('Copy from LHS', 0))
self.obj16870.Copy.config = 0
self.obj16870.Specify = ATOM3Constraint()
self.obj16870.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1687.GGset2Any['rate'] = self.obj16870
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1687)
self.obj1687.postAction(self.RHS.CREATE)
self.obj1688 = fromMaterial(parent)
self.obj1688.preAction(self.RHS.CREATE)
self.obj1688.isGraphObjectVisual = True
if (hasattr(self.obj1688, '_setHierarchicalLink')):
self.obj1688._setHierarchicalLink(False)
# rate
self.obj1688.rate.setValue(1.0)
self.obj1688.GGLabel.setValue(8)
self.obj1688.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(342.0, 110.0, self.obj1688)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1688.graphObject_ = new_obj
self.obj16880 = AttrCalc()
self.obj16880.Copy = ATOM3Boolean()
self.obj16880.Copy.setValue(('Copy from LHS', 0))
self.obj16880.Copy.config = 0
self.obj16880.Specify = ATOM3Constraint()
self.obj16880.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1688.GGset2Any['rate'] = self.obj16880
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1688)
self.obj1688.postAction(self.RHS.CREATE)
self.obj1689 = Goal(parent)
self.obj1689.preAction(self.RHS.CREATE)
self.obj1689.isGraphObjectVisual = True
if (hasattr(self.obj1689, '_setHierarchicalLink')):
self.obj1689._setHierarchicalLink(False)
# name
self.obj1689.name.setValue('')
self.obj1689.name.setNone()
self.obj1689.GGLabel.setValue(2)
self.obj1689.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(180.0, 60.0, self.obj1689)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1689.graphObject_ = new_obj
self.obj16890 = AttrCalc()
self.obj16890.Copy = ATOM3Boolean()
self.obj16890.Copy.setValue(('Copy from LHS', 1))
self.obj16890.Copy.config = 0
self.obj16890.Specify = ATOM3Constraint()
self.obj16890.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1689.GGset2Any['name'] = self.obj16890
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1689)
self.obj1689.postAction(self.RHS.CREATE)
self.obj1690 = GenericGraphEdge(parent)
self.obj1690.preAction(self.RHS.CREATE)
self.obj1690.isGraphObjectVisual = True
if (hasattr(self.obj1690, '_setHierarchicalLink')):
self.obj1690._setHierarchicalLink(False)
self.obj1690.GGLabel.setValue(4)
self.obj1690.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(264.5, 71.5, self.obj1690)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1690.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1690)
self.obj1690.postAction(self.RHS.CREATE)
self.obj1685.out_connections_.append(self.obj1688)
self.obj1688.in_connections_.append(self.obj1685)
self.obj1685.graphObject_.pendingConnections.append(
(self.obj1685.graphObject_.tag, self.obj1688.graphObject_.tag,
[244.0, 89.0, 342.0, 110.0], 0, True))
self.obj1686.out_connections_.append(self.obj1687)
self.obj1687.in_connections_.append(self.obj1686)
self.obj1686.graphObject_.pendingConnections.append(
(self.obj1686.graphObject_.tag, self.obj1687.graphObject_.tag,
[339.0, 158.0, 322.0, 179.0], 0, True))
self.obj1687.out_connections_.append(self.obj1684)
self.obj1684.in_connections_.append(self.obj1687)
self.obj1687.graphObject_.pendingConnections.append(
(self.obj1687.graphObject_.tag, self.obj1684.graphObject_.tag,
[305.0, 220.0, 322.0, 179.0], 0, True))
self.obj1688.out_connections_.append(self.obj1686)
self.obj1686.in_connections_.append(self.obj1688)
self.obj1688.graphObject_.pendingConnections.append(
(self.obj1688.graphObject_.tag, self.obj1686.graphObject_.tag,
[340.0, 151.0, 342.0, 110.0], 0, True))
self.obj1689.out_connections_.append(self.obj1690)
self.obj1690.in_connections_.append(self.obj1689)
self.obj1689.graphObject_.pendingConnections.append(
(self.obj1689.graphObject_.tag, self.obj1690.graphObject_.tag,
[93.0, 61.0, 264.5, 71.5], 2, 0))
self.obj1690.out_connections_.append(self.obj1685)
self.obj1685.in_connections_.append(self.obj1690)
self.obj1690.graphObject_.pendingConnections.append(
(self.obj1690.graphObject_.tag, self.obj1685.graphObject_.tag,
[226.0, 82.0, 264.5, 71.5], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 25)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.LHS.merge(ASG_GenericGraph(parent))
self.obj1815 = metarial(parent)
self.obj1815.preAction(self.LHS.CREATE)
self.obj1815.isGraphObjectVisual = True
if (hasattr(self.obj1815, '_setHierarchicalLink')):
self.obj1815._setHierarchicalLink(False)
# MaxFlow
self.obj1815.MaxFlow.setNone()
# price
self.obj1815.price.setValue(0)
# Name
self.obj1815.Name.setValue('')
self.obj1815.Name.setNone()
# ReqFlow
self.obj1815.ReqFlow.setNone()
self.obj1815.GGLabel.setValue(1)
self.obj1815.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 60.0, self.obj1815)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1815.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1815)
self.obj1815.postAction(self.LHS.CREATE)
self.obj1816 = Goal(parent)
self.obj1816.preAction(self.LHS.CREATE)
self.obj1816.isGraphObjectVisual = True
if (hasattr(self.obj1816, '_setHierarchicalLink')):
self.obj1816._setHierarchicalLink(False)
# name
self.obj1816.name.setValue('')
self.obj1816.name.setNone()
self.obj1816.GGLabel.setValue(3)
self.obj1816.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(100.0, 60.0, self.obj1816)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1816.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1816)
self.obj1816.postAction(self.LHS.CREATE)
self.obj1817 = GenericGraphEdge(parent)
self.obj1817.preAction(self.LHS.CREATE)
self.obj1817.isGraphObjectVisual = True
if (hasattr(self.obj1817, '_setHierarchicalLink')):
self.obj1817._setHierarchicalLink(False)
self.obj1817.GGLabel.setValue(4)
self.obj1817.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(205.0, 106.0, self.obj1817)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1817.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1817)
self.obj1817.postAction(self.LHS.CREATE)
self.obj1816.out_connections_.append(self.obj1817)
self.obj1817.in_connections_.append(self.obj1816)
self.obj1816.graphObject_.pendingConnections.append(
(self.obj1816.graphObject_.tag, self.obj1817.graphObject_.tag,
[124.0, 110.0, 205.0, 106.0], 0, True))
self.obj1817.out_connections_.append(self.obj1815)
self.obj1815.in_connections_.append(self.obj1817)
self.obj1817.graphObject_.pendingConnections.append(
(self.obj1817.graphObject_.tag, self.obj1815.graphObject_.tag,
[286.0, 102.0, 205.0, 106.0], 0, True))
self.RHS = ASG_pns(parent)
self.obj1819 = metarial(parent)
self.obj1819.preAction(self.RHS.CREATE)
self.obj1819.isGraphObjectVisual = True
if (hasattr(self.obj1819, '_setHierarchicalLink')):
self.obj1819._setHierarchicalLink(False)
# MaxFlow
self.obj1819.MaxFlow.setNone()
# price
self.obj1819.price.setValue(0)
# Name
self.obj1819.Name.setValue('')
self.obj1819.Name.setNone()
# ReqFlow
self.obj1819.ReqFlow.setNone()
self.obj1819.GGLabel.setValue(1)
self.obj1819.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(180.0, 40.0, self.obj1819)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1819.graphObject_ = new_obj
self.obj18190 = AttrCalc()
self.obj18190.Copy = ATOM3Boolean()
self.obj18190.Copy.setValue(('Copy from LHS', 1))
self.obj18190.Copy.config = 0
self.obj18190.Specify = ATOM3Constraint()
self.obj18190.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1819.GGset2Any['MaxFlow'] = self.obj18190
self.obj18191 = AttrCalc()
self.obj18191.Copy = ATOM3Boolean()
self.obj18191.Copy.setValue(('Copy from LHS', 1))
self.obj18191.Copy.config = 0
self.obj18191.Specify = ATOM3Constraint()
self.obj18191.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1819.GGset2Any['Name'] = self.obj18191
self.obj18192 = AttrCalc()
self.obj18192.Copy = ATOM3Boolean()
self.obj18192.Copy.setValue(('Copy from LHS', 1))
self.obj18192.Copy.config = 0
self.obj18192.Specify = ATOM3Constraint()
self.obj18192.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1819.GGset2Any['ReqFlow'] = self.obj18192
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1819)
self.obj1819.postAction(self.RHS.CREATE)
def __init__(self, parent):
GGrule.__init__(self, 11)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.obj1638 = Goal(parent)
self.obj1638.preAction(self.LHS.CREATE)
self.obj1638.isGraphObjectVisual = True
if (hasattr(self.obj1638, '_setHierarchicalLink')):
self.obj1638._setHierarchicalLink(False)
# name
self.obj1638.name.setValue('')
self.obj1638.name.setNone()
self.obj1638.GGLabel.setValue(1)
self.obj1638.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(80.0, 80.0, self.obj1638)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1638.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1638)
self.obj1638.postAction(self.LHS.CREATE)
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1642 = metarial(parent)
self.obj1642.preAction(self.RHS.CREATE)
self.obj1642.isGraphObjectVisual = True
if (hasattr(self.obj1642, '_setHierarchicalLink')):
self.obj1642._setHierarchicalLink(False)
# MaxFlow
self.obj1642.MaxFlow.setValue(999999)
# price
self.obj1642.price.setValue(0)
# Name
self.obj1642.Name.setValue('')
self.obj1642.Name.setNone()
# ReqFlow
self.obj1642.ReqFlow.setValue(0)
self.obj1642.GGLabel.setValue(2)
self.obj1642.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(300.0, 60.0, self.obj1642)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1642.graphObject_ = new_obj
self.obj16420 = AttrCalc()
self.obj16420.Copy = ATOM3Boolean()
self.obj16420.Copy.setValue(('Copy from LHS', 1))
self.obj16420.Copy.config = 0
self.obj16420.Specify = ATOM3Constraint()
self.obj16420.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1642.GGset2Any['MaxFlow'] = self.obj16420
self.obj16421 = AttrCalc()
self.obj16421.Copy = ATOM3Boolean()
self.obj16421.Copy.setValue(('Copy from LHS', 0))
self.obj16421.Copy.config = 0
self.obj16421.Specify = ATOM3Constraint()
self.obj16421.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
'return self.getMatched(graphID, self.LHS.nodeWithLabel(1)).name.getValue()\n'
))
self.obj1642.GGset2Any['Name'] = self.obj16421
self.obj16422 = AttrCalc()
self.obj16422.Copy = ATOM3Boolean()
self.obj16422.Copy.setValue(('Copy from LHS', 1))
self.obj16422.Copy.config = 0
self.obj16422.Specify = ATOM3Constraint()
self.obj16422.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1642.GGset2Any['ReqFlow'] = self.obj16422
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1642)
self.obj1642.postAction(self.RHS.CREATE)
self.obj1643 = Goal(parent)
self.obj1643.preAction(self.RHS.CREATE)
self.obj1643.isGraphObjectVisual = True
if (hasattr(self.obj1643, '_setHierarchicalLink')):
self.obj1643._setHierarchicalLink(False)
# name
self.obj1643.name.setValue('')
self.obj1643.name.setNone()
self.obj1643.GGLabel.setValue(1)
self.obj1643.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(80.0, 80.0, self.obj1643)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1643.graphObject_ = new_obj
self.obj16430 = AttrCalc()
self.obj16430.Copy = ATOM3Boolean()
self.obj16430.Copy.setValue(('Copy from LHS', 1))
self.obj16430.Copy.config = 0
self.obj16430.Specify = ATOM3Constraint()
self.obj16430.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1643.GGset2Any['name'] = self.obj16430
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1643)
self.obj1643.postAction(self.RHS.CREATE)
self.obj1644 = GenericGraphEdge(parent)
self.obj1644.preAction(self.RHS.CREATE)
self.obj1644.isGraphObjectVisual = True
if (hasattr(self.obj1644, '_setHierarchicalLink')):
self.obj1644._setHierarchicalLink(False)
self.obj1644.GGLabel.setValue(4)
self.obj1644.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(209.5, 91.5, self.obj1644)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1644.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1644)
self.obj1644.postAction(self.RHS.CREATE)
self.obj1643.out_connections_.append(self.obj1644)
self.obj1644.in_connections_.append(self.obj1643)
self.obj1643.graphObject_.pendingConnections.append(
(self.obj1643.graphObject_.tag, self.obj1644.graphObject_.tag,
[113.0, 81.0, 209.5, 91.5], 0, True))
self.obj1644.out_connections_.append(self.obj1642)
self.obj1642.in_connections_.append(self.obj1644)
self.obj1644.graphObject_.pendingConnections.append(
(self.obj1644.graphObject_.tag, self.obj1642.graphObject_.tag,
[306.0, 102.0, 209.5, 91.5], 0, True))
def goal_from_object(object, manip):
pose = object.GetTransform()
robot = manip.GetRobot()
env = robot.GetEnv()
#generate TSRs for object
if not 'bowl' in object.GetName():
target_tsrs = GetTSRListForObject(object, manip)
#turn TSR into poses
num_poses_desired = 30
max_num_poses_sample = 500
target_poses = []
target_iks = []
num_sampled = 0
while len(target_poses) < num_poses_desired and num_sampled < max_num_poses_sample:
print 'name: ' + object.GetName() + ' currently has ' + str(len(target_poses)) + ' goal poses'
if not 'bowl' in object.GetName():
num_sample_this = int(math.ceil(num_poses_desired/len(target_tsrs)))
num_sampled += num_sample_this
target_poses_idenframe = SampleTSRList(target_tsrs, num_sample_this)
target_poses_tocheck = [np.dot(object.GetTransform(), pose) for pose in target_poses_idenframe]
else:
num_sample_this = num_poses_desired
num_sampled += num_sample_this
target_poses_tocheck = get_bowl_poses(object, num_samples_pose=num_sample_this, ee_offset=0.15)
for pose in target_poses_tocheck:
#check if solution exists
# ik_sols = manip.FindIKSolutions(pose, openravepy.IkFilterOptions.CheckEnvCollisions)
# if len(ik_sols) > 0:
#sample some random joint vals
# lower, upper = robot.GetDOFLimits()
# dof_vals_before = robot.GetActiveDOFValues()
# dof_vals = [ np.random.uniform(lower[i], upper[i]) for i in range(6)]
# robot.SetActiveDOFValues(dof_vals)
# pose = manip.GetEndEffectorTransform()
# robot.SetActiveDOFValues(dof_vals_before)
ik_sol = manip.FindIKSolution(pose, openravepy.IkFilterOptions.CheckEnvCollisions)
if ik_sol is not None:
if ADD_MORE_IK_SOLS:
#get bigger list of ik solutions
ik_sols = manip.FindIKSolutions(pose, openravepy.IkFilterOptions.CheckEnvCollisions)
if ik_sols is None:
ik_sols = list()
else:
ik_sols = list(ik_sols)
#add the solution we found before
ik_sols.append(ik_sol)
else:
#if we don't want to add more, just use the one we found
ik_sols = [ik_sol]
#check env col
target_poses.append(pose)
target_iks.append(ik_sols)
# with robot:
# manip.SetDOFValues(ik_sol)
# if not env.CheckCollision(robot):
# target_poses.append(pose)
if len(target_poses) >= num_poses_desired:
break
return Goal(pose, target_poses, target_iks)
def __init__(self, parent):
GGrule.__init__(self, 17)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.obj1696=CapableOf(parent)
self.obj1696.preAction( self.LHS.CREATE )
self.obj1696.isGraphObjectVisual = True
if(hasattr(self.obj1696, '_setHierarchicalLink')):
self.obj1696._setHierarchicalLink(False)
# rate
self.obj1696.rate.setNone()
self.obj1696.GGLabel.setValue(4)
self.obj1696.graphClass_= graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(250.75,110.75,self.obj1696)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1696.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1696)
self.obj1696.postAction( self.LHS.CREATE )
self.obj1697=Goal(parent)
self.obj1697.preAction( self.LHS.CREATE )
self.obj1697.isGraphObjectVisual = True
if(hasattr(self.obj1697, '_setHierarchicalLink')):
self.obj1697._setHierarchicalLink(False)
# name
self.obj1697.name.setValue('')
self.obj1697.name.setNone()
self.obj1697.GGLabel.setValue(3)
self.obj1697.graphClass_= graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(100.0,240.0,self.obj1697)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1697.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1697)
self.obj1697.postAction( self.LHS.CREATE )
self.obj1698=Agent(parent)
self.obj1698.preAction( self.LHS.CREATE )
self.obj1698.isGraphObjectVisual = True
if(hasattr(self.obj1698, '_setHierarchicalLink')):
self.obj1698._setHierarchicalLink(False)
# price
self.obj1698.price.setNone()
# name
self.obj1698.name.setValue('')
self.obj1698.name.setNone()
self.obj1698.GGLabel.setValue(1)
self.obj1698.graphClass_= graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(80.0,40.0,self.obj1698)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1698.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1698)
self.obj1698.postAction( self.LHS.CREATE )
self.obj1699=Role(parent)
self.obj1699.preAction( self.LHS.CREATE )
self.obj1699.isGraphObjectVisual = True
if(hasattr(self.obj1699, '_setHierarchicalLink')):
self.obj1699._setHierarchicalLink(False)
# name
self.obj1699.name.setValue('')
self.obj1699.name.setNone()
self.obj1699.GGLabel.setValue(2)
self.obj1699.graphClass_= graph_Role
if parent.genGraphics:
new_obj = graph_Role(280.0,140.0,self.obj1699)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1699.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1699)
self.obj1699.postAction( self.LHS.CREATE )
self.obj1700=achieve(parent)
self.obj1700.preAction( self.LHS.CREATE )
self.obj1700.isGraphObjectVisual = True
if(hasattr(self.obj1700, '_setHierarchicalLink')):
self.obj1700._setHierarchicalLink(False)
# rate
self.obj1700.rate.setNone()
self.obj1700.GGLabel.setValue(5)
self.obj1700.graphClass_= graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(258.5,259.0,self.obj1700)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1700.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1700)
self.obj1700.postAction( self.LHS.CREATE )
self.obj1696.out_connections_.append(self.obj1699)
self.obj1699.in_connections_.append(self.obj1696)
self.obj1696.graphObject_.pendingConnections.append((self.obj1696.graphObject_.tag, self.obj1699.graphObject_.tag, [304.0, 141.0, 300.5, 120.5, 250.75, 110.75], 2, True))
self.obj1698.out_connections_.append(self.obj1696)
self.obj1696.in_connections_.append(self.obj1698)
self.obj1698.graphObject_.pendingConnections.append((self.obj1698.graphObject_.tag, self.obj1696.graphObject_.tag, [105.0, 102.0, 201.0, 101.0, 250.75, 110.75], 2, True))
self.obj1699.out_connections_.append(self.obj1700)
self.obj1700.in_connections_.append(self.obj1699)
self.obj1699.graphObject_.pendingConnections.append((self.obj1699.graphObject_.tag, self.obj1700.graphObject_.tag, [304.0, 186.0, 303.5, 233.0, 258.5, 259.0], 2, True))
self.obj1700.out_connections_.append(self.obj1697)
self.obj1697.in_connections_.append(self.obj1700)
self.obj1700.graphObject_.pendingConnections.append((self.obj1700.graphObject_.tag, self.obj1697.graphObject_.tag, [124.0, 290.0, 213.5, 285.0, 258.5, 259.0], 2, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1704=metarial(parent)
self.obj1704.preAction( self.RHS.CREATE )
self.obj1704.isGraphObjectVisual = True
if(hasattr(self.obj1704, '_setHierarchicalLink')):
self.obj1704._setHierarchicalLink(False)
# MaxFlow
self.obj1704.MaxFlow.setValue(999999)
# price
self.obj1704.price.setValue(0)
# Name
self.obj1704.Name.setValue('')
self.obj1704.Name.setNone()
# ReqFlow
self.obj1704.ReqFlow.setValue(0)
self.obj1704.GGLabel.setValue(8)
self.obj1704.graphClass_= graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(400.0,80.0,self.obj1704)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1704.graphObject_ = new_obj
self.obj17040= AttrCalc()
self.obj17040.Copy=ATOM3Boolean()
self.obj17040.Copy.setValue(('Copy from LHS', 1))
self.obj17040.Copy.config = 0
self.obj17040.Specify=ATOM3Constraint()
self.obj17040.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1704.GGset2Any['MaxFlow']= self.obj17040
self.obj17041= AttrCalc()
self.obj17041.Copy=ATOM3Boolean()
self.obj17041.Copy.setValue(('Copy from LHS', 0))
self.obj17041.Copy.config = 0
self.obj17041.Specify=ATOM3Constraint()
self.obj17041.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(1)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(3)).name.getValue()\n\n'))
self.obj1704.GGset2Any['Name']= self.obj17041
self.obj17042= AttrCalc()
self.obj17042.Copy=ATOM3Boolean()
self.obj17042.Copy.setValue(('Copy from LHS', 1))
self.obj17042.Copy.config = 0
self.obj17042.Specify=ATOM3Constraint()
self.obj17042.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1704.GGset2Any['ReqFlow']= self.obj17042
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1704)
self.obj1704.postAction( self.RHS.CREATE )
self.obj1705=operatingUnit(parent)
self.obj1705.preAction( self.RHS.CREATE )
self.obj1705.isGraphObjectVisual = True
if(hasattr(self.obj1705, '_setHierarchicalLink')):
self.obj1705._setHierarchicalLink(False)
# OperCostProp
self.obj1705.OperCostProp.setValue(0.0)
# name
self.obj1705.name.setValue('')
self.obj1705.name.setNone()
# OperCostFix
self.obj1705.OperCostFix.setValue(0.0)
self.obj1705.GGLabel.setValue(7)
self.obj1705.graphClass_= graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(400.0,240.0,self.obj1705)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1705.graphObject_ = new_obj
self.obj17050= AttrCalc()
self.obj17050.Copy=ATOM3Boolean()
self.obj17050.Copy.setValue(('Copy from LHS', 0))
self.obj17050.Copy.config = 0
self.obj17050.Specify=ATOM3Constraint()
self.obj17050.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(5)).rate.getValue()\n'))
self.obj1705.GGset2Any['OperCostProp']= self.obj17050
self.obj17051= AttrCalc()
self.obj17051.Copy=ATOM3Boolean()
self.obj17051.Copy.setValue(('Copy from LHS', 0))
self.obj17051.Copy.config = 0
self.obj17051.Specify=ATOM3Constraint()
self.obj17051.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return self.getMatched(graphID, self.LHS.nodeWithLabel(1)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(2)).name.getValue()+\' \'+ self.getMatched(graphID, self.LHS.nodeWithLabel(3)).name.getValue()\n\n\n\n\n\n\n'))
self.obj1705.GGset2Any['name']= self.obj17051
self.obj17052= AttrCalc()
self.obj17052.Copy=ATOM3Boolean()
self.obj17052.Copy.setValue(('Copy from LHS', 0))
self.obj17052.Copy.config = 0
self.obj17052.Specify=ATOM3Constraint()
self.obj17052.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), 'return 2.0\n'))
self.obj1705.GGset2Any['OperCostFix']= self.obj17052
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1705)
self.obj1705.postAction( self.RHS.CREATE )
self.obj1706=fromMaterial(parent)
self.obj1706.preAction( self.RHS.CREATE )
self.obj1706.isGraphObjectVisual = True
if(hasattr(self.obj1706, '_setHierarchicalLink')):
self.obj1706._setHierarchicalLink(False)
# rate
self.obj1706.rate.setValue(1.0)
self.obj1706.GGLabel.setValue(9)
self.obj1706.graphClass_= graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(422.0,190.0,self.obj1706)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1706.graphObject_ = new_obj
self.obj17060= AttrCalc()
self.obj17060.Copy=ATOM3Boolean()
self.obj17060.Copy.setValue(('Copy from LHS', 0))
self.obj17060.Copy.config = 0
self.obj17060.Specify=ATOM3Constraint()
self.obj17060.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1706.GGset2Any['rate']= self.obj17060
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1706)
self.obj1706.postAction( self.RHS.CREATE )
self.obj1707=CapableOf(parent)
self.obj1707.preAction( self.RHS.CREATE )
self.obj1707.isGraphObjectVisual = True
if(hasattr(self.obj1707, '_setHierarchicalLink')):
self.obj1707._setHierarchicalLink(False)
# rate
self.obj1707.rate.setNone()
self.obj1707.GGLabel.setValue(4)
self.obj1707.graphClass_= graph_CapableOf
if parent.genGraphics:
new_obj = graph_CapableOf(250.75,110.75,self.obj1707)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1707.graphObject_ = new_obj
self.obj17070= AttrCalc()
self.obj17070.Copy=ATOM3Boolean()
self.obj17070.Copy.setValue(('Copy from LHS', 1))
self.obj17070.Copy.config = 0
self.obj17070.Specify=ATOM3Constraint()
self.obj17070.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1707.GGset2Any['rate']= self.obj17070
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1707)
self.obj1707.postAction( self.RHS.CREATE )
self.obj1708=Goal(parent)
self.obj1708.preAction( self.RHS.CREATE )
self.obj1708.isGraphObjectVisual = True
if(hasattr(self.obj1708, '_setHierarchicalLink')):
self.obj1708._setHierarchicalLink(False)
# name
self.obj1708.name.setValue('')
self.obj1708.name.setNone()
self.obj1708.GGLabel.setValue(3)
self.obj1708.graphClass_= graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(100.0,240.0,self.obj1708)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1708.graphObject_ = new_obj
self.obj17080= AttrCalc()
self.obj17080.Copy=ATOM3Boolean()
self.obj17080.Copy.setValue(('Copy from LHS', 1))
self.obj17080.Copy.config = 0
self.obj17080.Specify=ATOM3Constraint()
self.obj17080.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1708.GGset2Any['name']= self.obj17080
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1708)
self.obj1708.postAction( self.RHS.CREATE )
self.obj1709=Agent(parent)
self.obj1709.preAction( self.RHS.CREATE )
self.obj1709.isGraphObjectVisual = True
if(hasattr(self.obj1709, '_setHierarchicalLink')):
self.obj1709._setHierarchicalLink(False)
# price
self.obj1709.price.setNone()
# name
self.obj1709.name.setValue('')
self.obj1709.name.setNone()
self.obj1709.GGLabel.setValue(1)
self.obj1709.graphClass_= graph_Agent
if parent.genGraphics:
new_obj = graph_Agent(80.0,40.0,self.obj1709)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1709.graphObject_ = new_obj
self.obj17090= AttrCalc()
self.obj17090.Copy=ATOM3Boolean()
self.obj17090.Copy.setValue(('Copy from LHS', 1))
self.obj17090.Copy.config = 0
self.obj17090.Specify=ATOM3Constraint()
self.obj17090.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1709.GGset2Any['price']= self.obj17090
self.obj17091= AttrCalc()
self.obj17091.Copy=ATOM3Boolean()
self.obj17091.Copy.setValue(('Copy from LHS', 1))
self.obj17091.Copy.config = 0
self.obj17091.Specify=ATOM3Constraint()
self.obj17091.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1709.GGset2Any['name']= self.obj17091
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1709)
self.obj1709.postAction( self.RHS.CREATE )
self.obj1710=Role(parent)
self.obj1710.preAction( self.RHS.CREATE )
self.obj1710.isGraphObjectVisual = True
if(hasattr(self.obj1710, '_setHierarchicalLink')):
self.obj1710._setHierarchicalLink(False)
# name
self.obj1710.name.setValue('')
self.obj1710.name.setNone()
self.obj1710.GGLabel.setValue(2)
self.obj1710.graphClass_= graph_Role
if parent.genGraphics:
new_obj = graph_Role(280.0,140.0,self.obj1710)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1710.graphObject_ = new_obj
self.obj17100= AttrCalc()
self.obj17100.Copy=ATOM3Boolean()
self.obj17100.Copy.setValue(('Copy from LHS', 1))
self.obj17100.Copy.config = 0
self.obj17100.Specify=ATOM3Constraint()
self.obj17100.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1710.GGset2Any['name']= self.obj17100
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1710)
self.obj1710.postAction( self.RHS.CREATE )
self.obj1711=achieve(parent)
self.obj1711.preAction( self.RHS.CREATE )
self.obj1711.isGraphObjectVisual = True
if(hasattr(self.obj1711, '_setHierarchicalLink')):
self.obj1711._setHierarchicalLink(False)
# rate
self.obj1711.rate.setNone()
self.obj1711.GGLabel.setValue(5)
self.obj1711.graphClass_= graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(258.5,259.0,self.obj1711)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else: new_obj = None
self.obj1711.graphObject_ = new_obj
self.obj17110= AttrCalc()
self.obj17110.Copy=ATOM3Boolean()
self.obj17110.Copy.setValue(('Copy from LHS', 1))
self.obj17110.Copy.config = 0
self.obj17110.Specify=ATOM3Constraint()
self.obj17110.Specify.setValue(('AttrSpecify', (['Python', 'OCL'], 0), (['PREcondition', 'POSTcondition'], 1), (['EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT', 'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1711.GGset2Any['rate']= self.obj17110
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1711)
self.obj1711.postAction( self.RHS.CREATE )
self.obj1712=GenericGraphEdge(parent)
self.obj1712.preAction( self.RHS.CREATE )
self.obj1712.isGraphObjectVisual = True
if(hasattr(self.obj1712, '_setHierarchicalLink')):
self.obj1712._setHierarchicalLink(False)
self.obj1712.GGLabel.setValue(10)
self.obj1712.graphClass_= graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(358.5,131.0,self.obj1712)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else: new_obj = None
self.obj1712.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1712)
self.obj1712.postAction( self.RHS.CREATE )
self.obj1704.out_connections_.append(self.obj1706)
self.obj1706.in_connections_.append(self.obj1704)
self.obj1704.graphObject_.pendingConnections.append((self.obj1704.graphObject_.tag, self.obj1706.graphObject_.tag, [424.0, 129.0, 422.0, 190.0], 0, True))
self.obj1706.out_connections_.append(self.obj1705)
self.obj1705.in_connections_.append(self.obj1706)
self.obj1706.graphObject_.pendingConnections.append((self.obj1706.graphObject_.tag, self.obj1705.graphObject_.tag, [420.0, 251.0, 422.0, 190.0], 0, True))
self.obj1707.out_connections_.append(self.obj1710)
self.obj1710.in_connections_.append(self.obj1707)
self.obj1707.graphObject_.pendingConnections.append((self.obj1707.graphObject_.tag, self.obj1710.graphObject_.tag, [311.0, 140.0, 250.75, 110.75], 2, 0))
self.obj1709.out_connections_.append(self.obj1707)
self.obj1707.in_connections_.append(self.obj1709)
self.obj1709.graphObject_.pendingConnections.append((self.obj1709.graphObject_.tag, self.obj1707.graphObject_.tag, [117.0, 102.0, 250.75, 110.75], 2, 0))
self.obj1710.out_connections_.append(self.obj1711)
self.obj1711.in_connections_.append(self.obj1710)
self.obj1710.graphObject_.pendingConnections.append((self.obj1710.graphObject_.tag, self.obj1711.graphObject_.tag, [311.0, 185.0, 258.5, 259.0], 2, 0))
self.obj1710.out_connections_.append(self.obj1712)
self.obj1712.in_connections_.append(self.obj1710)
self.obj1710.graphObject_.pendingConnections.append((self.obj1710.graphObject_.tag, self.obj1712.graphObject_.tag, [311.0, 140.0, 358.5, 131.0], 0, True))
self.obj1711.out_connections_.append(self.obj1708)
self.obj1708.in_connections_.append(self.obj1711)
self.obj1711.graphObject_.pendingConnections.append((self.obj1711.graphObject_.tag, self.obj1708.graphObject_.tag, [134.0, 290.0, 258.5, 259.0], 2, 0))
self.obj1712.out_connections_.append(self.obj1704)
self.obj1704.in_connections_.append(self.obj1712)
self.obj1712.graphObject_.pendingConnections.append((self.obj1712.graphObject_.tag, self.obj1704.graphObject_.tag, [406.0, 122.0, 358.5, 131.0], 0, True))
def add_goal(self, x, y, width, height, player_id): self.goals.append(Goal(x, y, width, height, self.players[player_id]))
def loadLevel(self, levelFile):
f = open("Resources/levels/" + levelFile, 'r')
lines = f.readlines()
f.close()
"""
print lines
print "________________________"
for line in lines:
print line
print "________________________"
"""
newlines = []
for line in lines:
newline = ""
for c in line:
if c != '\n':
newline += c
newlines += [newline]
lines = newlines
for line in lines:
print line
print "________________________"
for y, line in enumerate(lines):
for x, c in enumerate(line):
if c == '#':
self.walls += [
Wall("wall.png", [
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
if c == "@":
self.player = Player([
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
if c == ".":
self.enemies += [
Enemy([
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
if c == "$":
self.goal = Goal([
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
if c in "x":
self.enemies += [
Enemy(1, [
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
if c in "y":
self.enemies += [
ShootingEnemy(1, [
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
playerimage=pygame.transform.scale(playerimage,(30,30)) os.environ['SDL_VIDEO_CENTERED'] = '1' #centers the application window in the middle of the screen on startup pygame.init() #initialize the screen to size 800 x 600 gameDisplay = pygame.display.set_mode((1000, 1000)) #creates the Player character in the location 20, 20 player = Player.Player(30, 30,playerimage) #Defines the starting positions of the first two Particles for level 1 of the game particle1 = Particle.Particle(100, 100, False, None,redParticle,False) particle2 = Particle.Particle(100, 200, True, particle1,blueParticle,False) #Particle 2 is entangled to Particle one #Defines the position for the first goal for level 1 of the game goal = Goal.Goal(400, 400) door=Door.Door(760,300,20,100) #NOTE: Negative numbers in wall declarations ruin collision detection leftWall = Wall.Wall(0, 0, 20, 600) rightWall = Wall.Wall(780, 0, 20, 600) topWall = Wall.Wall(0, 0, 800, 20) bottomWall = Wall.Wall(0, 580, 800, 20) walls=[topWall,bottomWall,rightWall,leftWall] #Defines the objects that the Player character cannot pass through entities = [player,particle1, particle2, leftWall, rightWall, topWall, bottomWall] particles=[particle1,particle2]
def __init__(self, parent):
GGrule.__init__(self, 19)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.LHS.merge(ASG_GenericGraph(parent))
self.obj1719 = metarial(parent)
self.obj1719.preAction(self.LHS.CREATE)
self.obj1719.isGraphObjectVisual = True
if (hasattr(self.obj1719, '_setHierarchicalLink')):
self.obj1719._setHierarchicalLink(False)
# MaxFlow
self.obj1719.MaxFlow.setNone()
# price
self.obj1719.price.setValue(0)
# Name
self.obj1719.Name.setValue('')
self.obj1719.Name.setNone()
# ReqFlow
self.obj1719.ReqFlow.setNone()
self.obj1719.GGLabel.setValue(4)
self.obj1719.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(240.0, 20.0, self.obj1719)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1719.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1719)
self.obj1719.postAction(self.LHS.CREATE)
self.obj1720 = metarial(parent)
self.obj1720.preAction(self.LHS.CREATE)
self.obj1720.isGraphObjectVisual = True
if (hasattr(self.obj1720, '_setHierarchicalLink')):
self.obj1720._setHierarchicalLink(False)
# MaxFlow
self.obj1720.MaxFlow.setNone()
# price
self.obj1720.price.setValue(0)
# Name
self.obj1720.Name.setValue('')
self.obj1720.Name.setNone()
# ReqFlow
self.obj1720.ReqFlow.setNone()
self.obj1720.GGLabel.setValue(6)
self.obj1720.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(240.0, 240.0, self.obj1720)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1720.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1720)
self.obj1720.postAction(self.LHS.CREATE)
self.obj1721 = operatingUnit(parent)
self.obj1721.preAction(self.LHS.CREATE)
self.obj1721.isGraphObjectVisual = True
if (hasattr(self.obj1721, '_setHierarchicalLink')):
self.obj1721._setHierarchicalLink(False)
# OperCostProp
self.obj1721.OperCostProp.setNone()
# name
self.obj1721.name.setValue('')
self.obj1721.name.setNone()
# OperCostFix
self.obj1721.OperCostFix.setNone()
self.obj1721.GGLabel.setValue(5)
self.obj1721.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(240.0, 140.0, self.obj1721)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1721.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1721)
self.obj1721.postAction(self.LHS.CREATE)
self.obj1722 = fromMaterial(parent)
self.obj1722.preAction(self.LHS.CREATE)
self.obj1722.isGraphObjectVisual = True
if (hasattr(self.obj1722, '_setHierarchicalLink')):
self.obj1722._setHierarchicalLink(False)
# rate
self.obj1722.rate.setNone()
self.obj1722.GGLabel.setValue(8)
self.obj1722.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(265.0, 100.0, self.obj1722)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1722.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1722)
self.obj1722.postAction(self.LHS.CREATE)
self.obj1723 = Goal(parent)
self.obj1723.preAction(self.LHS.CREATE)
self.obj1723.isGraphObjectVisual = True
if (hasattr(self.obj1723, '_setHierarchicalLink')):
self.obj1723._setHierarchicalLink(False)
# name
self.obj1723.name.setValue('')
self.obj1723.name.setNone()
self.obj1723.GGLabel.setValue(2)
self.obj1723.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(60.0, 220.0, self.obj1723)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1723.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1723)
self.obj1723.postAction(self.LHS.CREATE)
self.obj1724 = Role(parent)
self.obj1724.preAction(self.LHS.CREATE)
self.obj1724.isGraphObjectVisual = True
if (hasattr(self.obj1724, '_setHierarchicalLink')):
self.obj1724._setHierarchicalLink(False)
# name
self.obj1724.name.setValue('')
self.obj1724.name.setNone()
self.obj1724.GGLabel.setValue(1)
self.obj1724.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(60.0, 40.0, self.obj1724)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1724.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1724)
self.obj1724.postAction(self.LHS.CREATE)
self.obj1725 = achieve(parent)
self.obj1725.preAction(self.LHS.CREATE)
self.obj1725.isGraphObjectVisual = True
if (hasattr(self.obj1725, '_setHierarchicalLink')):
self.obj1725._setHierarchicalLink(False)
# rate
self.obj1725.rate.setNone()
self.obj1725.GGLabel.setValue(3)
self.obj1725.graphClass_ = graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(97.5, 137.5, self.obj1725)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1725.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1725)
self.obj1725.postAction(self.LHS.CREATE)
self.obj1726 = GenericGraphEdge(parent)
self.obj1726.preAction(self.LHS.CREATE)
self.obj1726.isGraphObjectVisual = True
if (hasattr(self.obj1726, '_setHierarchicalLink')):
self.obj1726._setHierarchicalLink(False)
self.obj1726.GGLabel.setValue(7)
self.obj1726.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(215.0, 41.5, self.obj1726)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1726.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1726)
self.obj1726.postAction(self.LHS.CREATE)
self.obj1727 = GenericGraphEdge(parent)
self.obj1727.preAction(self.LHS.CREATE)
self.obj1727.isGraphObjectVisual = True
if (hasattr(self.obj1727, '_setHierarchicalLink')):
self.obj1727._setHierarchicalLink(False)
self.obj1727.GGLabel.setValue(9)
self.obj1727.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(185.0, 276.0, self.obj1727)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1727.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1727)
self.obj1727.postAction(self.LHS.CREATE)
self.obj1719.out_connections_.append(self.obj1722)
self.obj1722.in_connections_.append(self.obj1719)
self.obj1719.graphObject_.pendingConnections.append(
(self.obj1719.graphObject_.tag, self.obj1722.graphObject_.tag,
[264.0, 69.0, 265.0, 100.0], 0, True))
self.obj1722.out_connections_.append(self.obj1721)
self.obj1721.in_connections_.append(self.obj1722)
self.obj1722.graphObject_.pendingConnections.append(
(self.obj1722.graphObject_.tag, self.obj1721.graphObject_.tag,
[260.0, 151.0, 352.0, 90.0], 0, True))
self.obj1723.out_connections_.append(self.obj1727)
self.obj1727.in_connections_.append(self.obj1723)
self.obj1723.graphObject_.pendingConnections.append(
(self.obj1723.graphObject_.tag, self.obj1727.graphObject_.tag,
[84.0, 270.0, 185.0, 276.0], 0, True))
self.obj1724.out_connections_.append(self.obj1725)
self.obj1725.in_connections_.append(self.obj1724)
self.obj1724.graphObject_.pendingConnections.append(
(self.obj1724.graphObject_.tag, self.obj1725.graphObject_.tag,
[84.0, 86.0, 97.5, 137.5], 0, True))
self.obj1724.out_connections_.append(self.obj1726)
self.obj1726.in_connections_.append(self.obj1724)
self.obj1724.graphObject_.pendingConnections.append(
(self.obj1724.graphObject_.tag, self.obj1726.graphObject_.tag,
[84.0, 41.0, 215.0, 41.5], 0, True))
self.obj1725.out_connections_.append(self.obj1723)
self.obj1723.in_connections_.append(self.obj1725)
self.obj1725.graphObject_.pendingConnections.append(
(self.obj1725.graphObject_.tag, self.obj1723.graphObject_.tag,
[83.0, 221.0, 93.5, 143.5], 0, True))
self.obj1726.out_connections_.append(self.obj1719)
self.obj1719.in_connections_.append(self.obj1726)
self.obj1726.graphObject_.pendingConnections.append(
(self.obj1726.graphObject_.tag, self.obj1719.graphObject_.tag,
[246.0, 62.0, 215.0, 41.5], 0, True))
self.obj1727.out_connections_.append(self.obj1720)
self.obj1720.in_connections_.append(self.obj1727)
self.obj1727.graphObject_.pendingConnections.append(
(self.obj1727.graphObject_.tag, self.obj1720.graphObject_.tag,
[246.0, 282.0, 185.0, 276.0], 0, True))
self.RHS = ASG_pns(parent)
self.RHS.merge(ASG_omacs(parent))
self.RHS.merge(ASG_GenericGraph(parent))
self.obj1731 = metarial(parent)
self.obj1731.preAction(self.RHS.CREATE)
self.obj1731.isGraphObjectVisual = True
if (hasattr(self.obj1731, '_setHierarchicalLink')):
self.obj1731._setHierarchicalLink(False)
# MaxFlow
self.obj1731.MaxFlow.setNone()
# price
self.obj1731.price.setValue(0)
# Name
self.obj1731.Name.setValue('')
self.obj1731.Name.setNone()
# ReqFlow
self.obj1731.ReqFlow.setNone()
self.obj1731.GGLabel.setValue(4)
self.obj1731.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 20.0, self.obj1731)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1731.graphObject_ = new_obj
self.obj17310 = AttrCalc()
self.obj17310.Copy = ATOM3Boolean()
self.obj17310.Copy.setValue(('Copy from LHS', 1))
self.obj17310.Copy.config = 0
self.obj17310.Specify = ATOM3Constraint()
self.obj17310.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1731.GGset2Any['MaxFlow'] = self.obj17310
self.obj17311 = AttrCalc()
self.obj17311.Copy = ATOM3Boolean()
self.obj17311.Copy.setValue(('Copy from LHS', 1))
self.obj17311.Copy.config = 0
self.obj17311.Specify = ATOM3Constraint()
self.obj17311.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1731.GGset2Any['Name'] = self.obj17311
self.obj17312 = AttrCalc()
self.obj17312.Copy = ATOM3Boolean()
self.obj17312.Copy.setValue(('Copy from LHS', 1))
self.obj17312.Copy.config = 0
self.obj17312.Specify = ATOM3Constraint()
self.obj17312.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1731.GGset2Any['ReqFlow'] = self.obj17312
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1731)
self.obj1731.postAction(self.RHS.CREATE)
self.obj1732 = metarial(parent)
self.obj1732.preAction(self.RHS.CREATE)
self.obj1732.isGraphObjectVisual = True
if (hasattr(self.obj1732, '_setHierarchicalLink')):
self.obj1732._setHierarchicalLink(False)
# MaxFlow
self.obj1732.MaxFlow.setNone()
# price
self.obj1732.price.setValue(0)
# Name
self.obj1732.Name.setValue('')
self.obj1732.Name.setNone()
# ReqFlow
self.obj1732.ReqFlow.setNone()
self.obj1732.GGLabel.setValue(6)
self.obj1732.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 240.0, self.obj1732)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1732.graphObject_ = new_obj
self.obj17320 = AttrCalc()
self.obj17320.Copy = ATOM3Boolean()
self.obj17320.Copy.setValue(('Copy from LHS', 1))
self.obj17320.Copy.config = 0
self.obj17320.Specify = ATOM3Constraint()
self.obj17320.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1732.GGset2Any['MaxFlow'] = self.obj17320
self.obj17321 = AttrCalc()
self.obj17321.Copy = ATOM3Boolean()
self.obj17321.Copy.setValue(('Copy from LHS', 1))
self.obj17321.Copy.config = 0
self.obj17321.Specify = ATOM3Constraint()
self.obj17321.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1732.GGset2Any['Name'] = self.obj17321
self.obj17322 = AttrCalc()
self.obj17322.Copy = ATOM3Boolean()
self.obj17322.Copy.setValue(('Copy from LHS', 1))
self.obj17322.Copy.config = 0
self.obj17322.Specify = ATOM3Constraint()
self.obj17322.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1732.GGset2Any['ReqFlow'] = self.obj17322
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1732)
self.obj1732.postAction(self.RHS.CREATE)
self.obj1733 = operatingUnit(parent)
self.obj1733.preAction(self.RHS.CREATE)
self.obj1733.isGraphObjectVisual = True
if (hasattr(self.obj1733, '_setHierarchicalLink')):
self.obj1733._setHierarchicalLink(False)
# OperCostProp
self.obj1733.OperCostProp.setNone()
# name
self.obj1733.name.setValue('')
self.obj1733.name.setNone()
# OperCostFix
self.obj1733.OperCostFix.setNone()
self.obj1733.GGLabel.setValue(5)
self.obj1733.graphClass_ = graph_operatingUnit
if parent.genGraphics:
new_obj = graph_operatingUnit(280.0, 140.0, self.obj1733)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1733.graphObject_ = new_obj
self.obj17330 = AttrCalc()
self.obj17330.Copy = ATOM3Boolean()
self.obj17330.Copy.setValue(('Copy from LHS', 1))
self.obj17330.Copy.config = 0
self.obj17330.Specify = ATOM3Constraint()
self.obj17330.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1733.GGset2Any['OperCostProp'] = self.obj17330
self.obj17331 = AttrCalc()
self.obj17331.Copy = ATOM3Boolean()
self.obj17331.Copy.setValue(('Copy from LHS', 1))
self.obj17331.Copy.config = 0
self.obj17331.Specify = ATOM3Constraint()
self.obj17331.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1733.GGset2Any['name'] = self.obj17331
self.obj17332 = AttrCalc()
self.obj17332.Copy = ATOM3Boolean()
self.obj17332.Copy.setValue(('Copy from LHS', 1))
self.obj17332.Copy.config = 0
self.obj17332.Specify = ATOM3Constraint()
self.obj17332.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1733.GGset2Any['OperCostFix'] = self.obj17332
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1733)
self.obj1733.postAction(self.RHS.CREATE)
self.obj1734 = intoMaterial(parent)
self.obj1734.preAction(self.RHS.CREATE)
self.obj1734.isGraphObjectVisual = True
if (hasattr(self.obj1734, '_setHierarchicalLink')):
self.obj1734._setHierarchicalLink(False)
# rate
self.obj1734.rate.setValue(0.0)
self.obj1734.GGLabel.setValue(10)
self.obj1734.graphClass_ = graph_intoMaterial
if parent.genGraphics:
new_obj = graph_intoMaterial(315.25, 202.5, self.obj1734)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1734.graphObject_ = new_obj
self.obj17340 = AttrCalc()
self.obj17340.Copy = ATOM3Boolean()
self.obj17340.Copy.setValue(('Copy from LHS', 0))
self.obj17340.Copy.config = 0
self.obj17340.Specify = ATOM3Constraint()
self.obj17340.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
'return self.getMatched(graphID, self.LHS.nodeWithLabel(3)).rate.getValue()\n\n\n\n\n\n\n\n\n\n'
))
self.obj1734.GGset2Any['rate'] = self.obj17340
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1734)
self.obj1734.postAction(self.RHS.CREATE)
self.obj1735 = fromMaterial(parent)
self.obj1735.preAction(self.RHS.CREATE)
self.obj1735.isGraphObjectVisual = True
if (hasattr(self.obj1735, '_setHierarchicalLink')):
self.obj1735._setHierarchicalLink(False)
# rate
self.obj1735.rate.setNone()
self.obj1735.GGLabel.setValue(8)
self.obj1735.graphClass_ = graph_fromMaterial
if parent.genGraphics:
new_obj = graph_fromMaterial(323.0, 83.0, self.obj1735)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1735.graphObject_ = new_obj
self.obj17350 = AttrCalc()
self.obj17350.Copy = ATOM3Boolean()
self.obj17350.Copy.setValue(('Copy from LHS', 1))
self.obj17350.Copy.config = 0
self.obj17350.Specify = ATOM3Constraint()
self.obj17350.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1735.GGset2Any['rate'] = self.obj17350
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1735)
self.obj1735.postAction(self.RHS.CREATE)
self.obj1736 = Goal(parent)
self.obj1736.preAction(self.RHS.CREATE)
self.obj1736.isGraphObjectVisual = True
if (hasattr(self.obj1736, '_setHierarchicalLink')):
self.obj1736._setHierarchicalLink(False)
# name
self.obj1736.name.setValue('')
self.obj1736.name.setNone()
self.obj1736.GGLabel.setValue(2)
self.obj1736.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(60.0, 220.0, self.obj1736)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1736.graphObject_ = new_obj
self.obj17360 = AttrCalc()
self.obj17360.Copy = ATOM3Boolean()
self.obj17360.Copy.setValue(('Copy from LHS', 1))
self.obj17360.Copy.config = 0
self.obj17360.Specify = ATOM3Constraint()
self.obj17360.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1736.GGset2Any['name'] = self.obj17360
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1736)
self.obj1736.postAction(self.RHS.CREATE)
self.obj1737 = Role(parent)
self.obj1737.preAction(self.RHS.CREATE)
self.obj1737.isGraphObjectVisual = True
if (hasattr(self.obj1737, '_setHierarchicalLink')):
self.obj1737._setHierarchicalLink(False)
# name
self.obj1737.name.setValue('')
self.obj1737.name.setNone()
self.obj1737.GGLabel.setValue(1)
self.obj1737.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(60.0, 40.0, self.obj1737)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1737.graphObject_ = new_obj
self.obj17370 = AttrCalc()
self.obj17370.Copy = ATOM3Boolean()
self.obj17370.Copy.setValue(('Copy from LHS', 1))
self.obj17370.Copy.config = 0
self.obj17370.Specify = ATOM3Constraint()
self.obj17370.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1737.GGset2Any['name'] = self.obj17370
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1737)
self.obj1737.postAction(self.RHS.CREATE)
self.obj1738 = achieve(parent)
self.obj1738.preAction(self.RHS.CREATE)
self.obj1738.isGraphObjectVisual = True
if (hasattr(self.obj1738, '_setHierarchicalLink')):
self.obj1738._setHierarchicalLink(False)
# rate
self.obj1738.rate.setNone()
self.obj1738.GGLabel.setValue(3)
self.obj1738.graphClass_ = graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(93.5, 143.5, self.obj1738)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1738.graphObject_ = new_obj
self.obj17380 = AttrCalc()
self.obj17380.Copy = ATOM3Boolean()
self.obj17380.Copy.setValue(('Copy from LHS', 1))
self.obj17380.Copy.config = 0
self.obj17380.Specify = ATOM3Constraint()
self.obj17380.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1738.GGset2Any['rate'] = self.obj17380
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1738)
self.obj1738.postAction(self.RHS.CREATE)
self.obj1739 = GenericGraphEdge(parent)
self.obj1739.preAction(self.RHS.CREATE)
self.obj1739.isGraphObjectVisual = True
if (hasattr(self.obj1739, '_setHierarchicalLink')):
self.obj1739._setHierarchicalLink(False)
self.obj1739.GGLabel.setValue(7)
self.obj1739.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(215.0, 41.5, self.obj1739)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1739.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1739)
self.obj1739.postAction(self.RHS.CREATE)
self.obj1740 = GenericGraphEdge(parent)
self.obj1740.preAction(self.RHS.CREATE)
self.obj1740.isGraphObjectVisual = True
if (hasattr(self.obj1740, '_setHierarchicalLink')):
self.obj1740._setHierarchicalLink(False)
self.obj1740.GGLabel.setValue(9)
self.obj1740.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(185.0, 276.0, self.obj1740)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1740.graphObject_ = new_obj
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1740)
self.obj1740.postAction(self.RHS.CREATE)
self.obj1731.out_connections_.append(self.obj1735)
self.obj1735.in_connections_.append(self.obj1731)
self.obj1731.graphObject_.pendingConnections.append(
(self.obj1731.graphObject_.tag, self.obj1735.graphObject_.tag,
[284.0, 69.0, 323.0, 83.0], 2, 0))
self.obj1733.out_connections_.append(self.obj1734)
self.obj1734.in_connections_.append(self.obj1733)
self.obj1733.graphObject_.pendingConnections.append(
(self.obj1733.graphObject_.tag, self.obj1734.graphObject_.tag,
[333.0, 148.0, 332.0, 167.0, 371.25, 179.5], 2, True))
self.obj1734.out_connections_.append(self.obj1732)
self.obj1732.in_connections_.append(self.obj1734)
self.obj1734.graphObject_.pendingConnections.append(
(self.obj1734.graphObject_.tag, self.obj1732.graphObject_.tag,
[326.0, 250.0, 354.5, 215.0, 371.25, 179.5], 2, True))
self.obj1735.out_connections_.append(self.obj1733)
self.obj1733.in_connections_.append(self.obj1735)
self.obj1735.graphObject_.pendingConnections.append(
(self.obj1735.graphObject_.tag, self.obj1733.graphObject_.tag,
[333.0, 148.0, 352.0, 90.0], 2, 0))
self.obj1736.out_connections_.append(self.obj1740)
self.obj1740.in_connections_.append(self.obj1736)
self.obj1736.graphObject_.pendingConnections.append(
(self.obj1736.graphObject_.tag, self.obj1740.graphObject_.tag,
[94.0, 270.0, 185.0, 276.0], 2, 0))
self.obj1737.out_connections_.append(self.obj1738)
self.obj1738.in_connections_.append(self.obj1737)
self.obj1737.graphObject_.pendingConnections.append(
(self.obj1737.graphObject_.tag, self.obj1738.graphObject_.tag,
[91.0, 85.0, 93.5, 143.5], 2, 0))
self.obj1737.out_connections_.append(self.obj1739)
self.obj1739.in_connections_.append(self.obj1737)
self.obj1737.graphObject_.pendingConnections.append(
(self.obj1737.graphObject_.tag, self.obj1739.graphObject_.tag,
[91.0, 40.0, 215.0, 41.5], 2, 0))
self.obj1738.out_connections_.append(self.obj1736)
self.obj1736.in_connections_.append(self.obj1738)
self.obj1738.graphObject_.pendingConnections.append(
(self.obj1738.graphObject_.tag, self.obj1736.graphObject_.tag,
[93.0, 221.0, 93.5, 143.5], 2, 0))
self.obj1739.out_connections_.append(self.obj1731)
self.obj1731.in_connections_.append(self.obj1739)
self.obj1739.graphObject_.pendingConnections.append(
(self.obj1739.graphObject_.tag, self.obj1731.graphObject_.tag,
[266.0, 62.0, 215.0, 41.5], 2, 0))
self.obj1740.out_connections_.append(self.obj1732)
self.obj1732.in_connections_.append(self.obj1740)
self.obj1740.graphObject_.pendingConnections.append(
(self.obj1740.graphObject_.tag, self.obj1732.graphObject_.tag,
[286.0, 282.0, 185.0, 276.0], 2, 0))
def __init__(self, parent):
GGrule.__init__(self, 6)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_omacs(parent)
self.obj1596 = Role(parent)
self.obj1596.preAction(self.LHS.CREATE)
self.obj1596.isGraphObjectVisual = True
if (hasattr(self.obj1596, '_setHierarchicalLink')):
self.obj1596._setHierarchicalLink(False)
# name
self.obj1596.name.setValue('')
self.obj1596.name.setNone()
self.obj1596.GGLabel.setValue(2)
self.obj1596.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(40.0, 40.0, self.obj1596)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1596.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1596)
self.obj1596.postAction(self.LHS.CREATE)
self.obj1597 = Goal(parent)
self.obj1597.preAction(self.LHS.CREATE)
self.obj1597.isGraphObjectVisual = True
if (hasattr(self.obj1597, '_setHierarchicalLink')):
self.obj1597._setHierarchicalLink(False)
# name
self.obj1597.name.setValue('')
self.obj1597.name.setNone()
self.obj1597.GGLabel.setValue(1)
self.obj1597.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(300.0, 160.0, self.obj1597)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1597.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1597)
self.obj1597.postAction(self.LHS.CREATE)
self.obj1598 = achieve(parent)
self.obj1598.preAction(self.LHS.CREATE)
self.obj1598.isGraphObjectVisual = True
if (hasattr(self.obj1598, '_setHierarchicalLink')):
self.obj1598._setHierarchicalLink(False)
# rate
self.obj1598.rate.setNone()
self.obj1598.GGLabel.setValue(3)
self.obj1598.graphClass_ = graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(171.25, 141.25, self.obj1598)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1598.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1598)
self.obj1598.postAction(self.LHS.CREATE)
self.obj1596.out_connections_.append(self.obj1598)
self.obj1598.in_connections_.append(self.obj1596)
self.obj1596.graphObject_.pendingConnections.append(
(self.obj1596.graphObject_.tag, self.obj1598.graphObject_.tag,
[64.0, 86.0, 106.5, 122.5, 171.25, 141.25], 2, True))
self.obj1598.out_connections_.append(self.obj1597)
self.obj1597.in_connections_.append(self.obj1598)
self.obj1598.graphObject_.pendingConnections.append(
(self.obj1598.graphObject_.tag, self.obj1597.graphObject_.tag,
[323.0, 161.0, 236.0, 160.0, 171.25, 141.25], 2, True))
self.RHS = ASG_omacs(parent)
self.obj1600 = Role(parent)
self.obj1600.preAction(self.RHS.CREATE)
self.obj1600.isGraphObjectVisual = True
if (hasattr(self.obj1600, '_setHierarchicalLink')):
self.obj1600._setHierarchicalLink(False)
# name
self.obj1600.name.setValue('')
self.obj1600.name.setNone()
self.obj1600.GGLabel.setValue(2)
self.obj1600.graphClass_ = graph_Role
if parent.genGraphics:
new_obj = graph_Role(40.0, 40.0, self.obj1600)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1600.graphObject_ = new_obj
self.obj16000 = AttrCalc()
self.obj16000.Copy = ATOM3Boolean()
self.obj16000.Copy.setValue(('Copy from LHS', 1))
self.obj16000.Copy.config = 0
self.obj16000.Specify = ATOM3Constraint()
self.obj16000.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1600.GGset2Any['name'] = self.obj16000
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1600)
self.obj1600.postAction(self.RHS.CREATE)
self.obj1601 = Goal(parent)
self.obj1601.preAction(self.RHS.CREATE)
self.obj1601.isGraphObjectVisual = True
if (hasattr(self.obj1601, '_setHierarchicalLink')):
self.obj1601._setHierarchicalLink(False)
# name
self.obj1601.name.setValue('')
self.obj1601.name.setNone()
self.obj1601.GGLabel.setValue(1)
self.obj1601.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(300.0, 160.0, self.obj1601)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1601.graphObject_ = new_obj
self.obj16010 = AttrCalc()
self.obj16010.Copy = ATOM3Boolean()
self.obj16010.Copy.setValue(('Copy from LHS', 1))
self.obj16010.Copy.config = 0
self.obj16010.Specify = ATOM3Constraint()
self.obj16010.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1601.GGset2Any['name'] = self.obj16010
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1601)
self.obj1601.postAction(self.RHS.CREATE)
self.obj1602 = achieve(parent)
self.obj1602.preAction(self.RHS.CREATE)
self.obj1602.isGraphObjectVisual = True
if (hasattr(self.obj1602, '_setHierarchicalLink')):
self.obj1602._setHierarchicalLink(False)
# rate
self.obj1602.rate.setNone()
self.obj1602.GGLabel.setValue(3)
self.obj1602.graphClass_ = graph_achieve
if parent.genGraphics:
new_obj = graph_achieve(171.25, 141.25, self.obj1602)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1602.graphObject_ = new_obj
self.obj16020 = AttrCalc()
self.obj16020.Copy = ATOM3Boolean()
self.obj16020.Copy.setValue(('Copy from LHS', 1))
self.obj16020.Copy.config = 0
self.obj16020.Specify = ATOM3Constraint()
self.obj16020.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1602.GGset2Any['rate'] = self.obj16020
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1602)
self.obj1602.postAction(self.RHS.CREATE)
self.obj1600.out_connections_.append(self.obj1602)
self.obj1602.in_connections_.append(self.obj1600)
self.obj1600.graphObject_.pendingConnections.append(
(self.obj1600.graphObject_.tag, self.obj1602.graphObject_.tag,
[71.0, 85.0, 171.25, 141.25], 2, 0))
self.obj1602.out_connections_.append(self.obj1601)
self.obj1601.in_connections_.append(self.obj1602)
self.obj1602.graphObject_.pendingConnections.append(
(self.obj1602.graphObject_.tag, self.obj1601.graphObject_.tag,
[333.0, 161.0, 171.25, 141.25], 2, 0))
from Goal import *
from Population import *
from Obstacle import *
goal = Goal()
all_sprites.add(goal)
population = Population()
def draw_text(surf, text, size, x, y):
font = pygame.font.Font(font_name, size)
text_surface = font.render(text, True, BLACK)
text_rect = text_surface.get_rect()
text_rect.midtop = (x, y)
surf.blit(text_surface, text_rect)
def handle_obstacles():
global lvl_up
global obs_index
if lvl_up and obs_index < len(obs_topleft_list):
Obstacle(obs_topleft_list[obs_index])
lvl_up = False
obs_index += 1
def evolve():
population.compute_total_fitness()
if population.generation % 2 == 1:
population.boost_fitness()
else:
gameOver = False # Boolean variable keeps the program running keep_going = True # Initialize left goal width, and left goalBaseBlock width width1 = 200 # Initialize right goal width, and right goalBaseBlock width width2 = 200 # Initialize the red paddle size pSize1 = 45 # Initialize the blue paddle size pSize2 = 45 # Create left goal (Draw out goal) goal1 = Goal(1, 0, 295, width1) # Create right goal (Draw out goal) goal2 = Goal(0, 985, 295, width2) # Create left goalBaseBlock (Used to detect if a goal is scored) goalBaseBlock1 = GoalBaseBlock(1, 0, 295, width1) # Create right goalBaseBlock (Used to detect if a goal is scored) goalBaseBlock2 = GoalBaseBlock(0, 1029, 295, width2) # Initialize left goalSideBlock width sideBlockWidth1 = 150 # Initialize right goalSideBlock width sideBlockWidth2 = 150 # Create left upper goalSideBlock (Draw side barrier for puck) goalSideBlockLU = GoalSideBlock(0, 0, 145, sideBlockWidth1)
class RemoveGoal_GG_rule(GGrule):
def __init__(self, parent):
GGrule.__init__(self, 25)
self.TimeDelay = ATOM3Integer(2)
self.exactMatch = 1
self.LHS = ASG_pns(parent)
self.LHS.merge(ASG_omacs(parent))
self.LHS.merge(ASG_GenericGraph(parent))
self.obj1815 = metarial(parent)
self.obj1815.preAction(self.LHS.CREATE)
self.obj1815.isGraphObjectVisual = True
if (hasattr(self.obj1815, '_setHierarchicalLink')):
self.obj1815._setHierarchicalLink(False)
# MaxFlow
self.obj1815.MaxFlow.setNone()
# price
self.obj1815.price.setValue(0)
# Name
self.obj1815.Name.setValue('')
self.obj1815.Name.setNone()
# ReqFlow
self.obj1815.ReqFlow.setNone()
self.obj1815.GGLabel.setValue(1)
self.obj1815.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(280.0, 60.0, self.obj1815)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1815.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1815)
self.obj1815.postAction(self.LHS.CREATE)
self.obj1816 = Goal(parent)
self.obj1816.preAction(self.LHS.CREATE)
self.obj1816.isGraphObjectVisual = True
if (hasattr(self.obj1816, '_setHierarchicalLink')):
self.obj1816._setHierarchicalLink(False)
# name
self.obj1816.name.setValue('')
self.obj1816.name.setNone()
self.obj1816.GGLabel.setValue(3)
self.obj1816.graphClass_ = graph_Goal
if parent.genGraphics:
new_obj = graph_Goal(100.0, 60.0, self.obj1816)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1816.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1816)
self.obj1816.postAction(self.LHS.CREATE)
self.obj1817 = GenericGraphEdge(parent)
self.obj1817.preAction(self.LHS.CREATE)
self.obj1817.isGraphObjectVisual = True
if (hasattr(self.obj1817, '_setHierarchicalLink')):
self.obj1817._setHierarchicalLink(False)
self.obj1817.GGLabel.setValue(4)
self.obj1817.graphClass_ = graph_GenericGraphEdge
if parent.genGraphics:
new_obj = graph_GenericGraphEdge(205.0, 106.0, self.obj1817)
new_obj.layConstraints = dict() # Graphical Layout Constraints
else:
new_obj = None
self.obj1817.graphObject_ = new_obj
# Add node to the root: self.LHS
self.LHS.addNode(self.obj1817)
self.obj1817.postAction(self.LHS.CREATE)
self.obj1816.out_connections_.append(self.obj1817)
self.obj1817.in_connections_.append(self.obj1816)
self.obj1816.graphObject_.pendingConnections.append(
(self.obj1816.graphObject_.tag, self.obj1817.graphObject_.tag,
[124.0, 110.0, 205.0, 106.0], 0, True))
self.obj1817.out_connections_.append(self.obj1815)
self.obj1815.in_connections_.append(self.obj1817)
self.obj1817.graphObject_.pendingConnections.append(
(self.obj1817.graphObject_.tag, self.obj1815.graphObject_.tag,
[286.0, 102.0, 205.0, 106.0], 0, True))
self.RHS = ASG_pns(parent)
self.obj1819 = metarial(parent)
self.obj1819.preAction(self.RHS.CREATE)
self.obj1819.isGraphObjectVisual = True
if (hasattr(self.obj1819, '_setHierarchicalLink')):
self.obj1819._setHierarchicalLink(False)
# MaxFlow
self.obj1819.MaxFlow.setNone()
# price
self.obj1819.price.setValue(0)
# Name
self.obj1819.Name.setValue('')
self.obj1819.Name.setNone()
# ReqFlow
self.obj1819.ReqFlow.setNone()
self.obj1819.GGLabel.setValue(1)
self.obj1819.graphClass_ = graph_metarial
if parent.genGraphics:
new_obj = graph_metarial(180.0, 40.0, self.obj1819)
new_obj.layConstraints = dict() # Graphical Layout Constraints
new_obj.layConstraints['scale'] = [1.0, 1.0]
else:
new_obj = None
self.obj1819.graphObject_ = new_obj
self.obj18190 = AttrCalc()
self.obj18190.Copy = ATOM3Boolean()
self.obj18190.Copy.setValue(('Copy from LHS', 1))
self.obj18190.Copy.config = 0
self.obj18190.Specify = ATOM3Constraint()
self.obj18190.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1819.GGset2Any['MaxFlow'] = self.obj18190
self.obj18191 = AttrCalc()
self.obj18191.Copy = ATOM3Boolean()
self.obj18191.Copy.setValue(('Copy from LHS', 1))
self.obj18191.Copy.config = 0
self.obj18191.Specify = ATOM3Constraint()
self.obj18191.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1819.GGset2Any['Name'] = self.obj18191
self.obj18192 = AttrCalc()
self.obj18192.Copy = ATOM3Boolean()
self.obj18192.Copy.setValue(('Copy from LHS', 1))
self.obj18192.Copy.config = 0
self.obj18192.Specify = ATOM3Constraint()
self.obj18192.Specify.setValue(
('AttrSpecify', (['Python', 'OCL'], 0),
(['PREcondition', 'POSTcondition'], 1), ([
'EDIT', 'SAVE', 'CREATE', 'CONNECT', 'DELETE', 'DISCONNECT',
'TRANSFORM', 'SELECT', 'DRAG', 'DROP', 'MOVE'
], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), None))
self.obj1819.GGset2Any['ReqFlow'] = self.obj18192
# Add node to the root: self.RHS
self.RHS.addNode(self.obj1819)
self.obj1819.postAction(self.RHS.CREATE)
def condition(self, graphID, isograph, atom3i):
return self.graphRewritingSystem.finalStat > 20
def action(self, graphID, isograph, atom3i):
# If you want to apply this rule at most once on asingle host graph node,
# then uncomment the next two lines. Change the default GG label (1) if needed.
# Make sure to enable the CONDITION code as well
# And to use the same label & unique name in the ACTION
# WARNING: _uniqueName503 is not guaranteed to be unique (so change it, be safe!)
#node = self.getMatched(graphID, self.LHS.nodeWithLabel(1))
#node._uniqueName503 = True
pass
mPR, mPS)
gpsData = GPS.readGPS()
Motor.motor(mPL, mPR, 0.1, 1)
Motor.motor(0, 0, 1)
print("Running Phase Finished")
IM920.Send("P7F")
# ------------------- GoalDetection Phase ------------------- #
if (phaseChk <= 8):
Other.saveLog(phaseLog, "8", "GoalDetection Phase Started",
time.time() - t_start)
print("Goal Detection Phase Started")
IM920.Send("P8S")
while goalFlug != 0 or goalBuf != 0:
gpsdata = GPS.readGPS()
goalFlug, goalArea, goalGAP, photoName = Goal.Togoal(
photopath, H_min, H_max, S_thd, mp_min, mp_max, mp_adj)
goalBuf = goalFlug
print("goal is", goalFlug)
Other.saveLog(goalDetectionLog,
time.time() - t_start, gpsData, goalFlug,
goalArea, goalGAP, photoName)
Other.saveLog(captureLog, time.time() - t_start, photoName)
print("Goal Detection Phase Finished")
IM920.Send("P8F")
print("Program Finished")
IM920.Send("P10")
Other.saveLog(phaseLog, "10", "Program Finished",
time.time() - t_start)
close()
except KeyboardInterrupt:
# Defining world dimensions
xlim = 500
ylim = 500
world_size = (xlim, ylim)
# Initializing blank canvas(OpenCV) with white color
image = np.ones((world_size[1], world_size[0], 3), dtype=np.uint8) * 255
# Defining agent and goal
aPosx = 200
aPosy = 50
agent = Agent(Position(aPosx, aPosy), scan_radius=10, possible_moves=30)
Matlab_agent_x = aPosx
Matlab_agent_y = ylim - aPosy
goal = Goal(Position(250, 450),
sigma=math.sqrt(world_size[0]**2 + world_size[1]**2))
# Defining obstacles in a list
sigma_obstacles = 5
obstacles = [
Obstacle(Position(150, 180),
sigma=sigma_obstacles,
draw_radius=4 * sigma_obstacles),
Obstacle(Position(150, 280),
sigma=sigma_obstacles,
draw_radius=4 * sigma_obstacles),
Obstacle(Position(150, 380),
sigma=sigma_obstacles,
draw_radius=4 * sigma_obstacles),
Obstacle(Position(250, 180),
sigma=sigma_obstacles,
def loadLevel(self, levelNumber):
f = open("rsc/levels/level"+str(levelNumber)+".lvl", 'r')
lines = f.readlines()
f.close()
"""
print lines
print "________________________"
for line in lines:
print line
print "________________________"
"""
newlines = []
for line in lines:
newline = ""
for c in line:
if c != '\n':
newline += c
newlines += [newline]
lines = newlines
for line in lines:
print line
print "________________________"
for y,line in enumerate(lines):
for x,c in enumerate(line):
if c == '#':
Wall([x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
self.tileSize)
if c == 'G':
Ground([x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
self.tileSize)
if c == 'P':
player = PlayerMeme(self.size, 7,
[x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2])
Arm(player)
if c == 'm':
Meme(self.size, 1,
[random.randint(7, 10), random.randint(7, 10)],
[x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
random.randint(20, 100))
if c == 'Q':
Wall_5x5([x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
self.tileSize)
if c == '1':
GunPickup("health",
[x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
self.tileSize)
if c == "$":
self.goal = Goal([x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
self.tileSize)
if c == '2':
BossMeme(self.size,
[x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
self.tileSize)
if c == '3':
EndFlag([x*self.tileSize + self.tileSize/2,
y*self.tileSize + self.tileSize/2],
self.tileSize)
from Player import *
from Scoreboard import *
pygame.init()
clock = pygame.time.Clock()
width = 1000
height = 700
size = width, height
screen = pygame.display.set_mode(size)
bgColor = r, g, b = 0, 128, 33
bgImage = pygame.image.load("Images/field/fieldfull.png")
bgRect = bgImage.get_rect()
ball = Ball(size, [40, 40])
rGoal = Goal("right", size)
lGoal = Goal("left", size)
p1 = Playerball("right", size, [70, 70])
p2 = Playerball("left", size, [70, 70])
rScore = Scoreboard([width / 2 + 50, 25], "right")
lScore = Scoreboard([width / 2 - 50, 25], "left")
mode = "menu"
while True:
while mode == "menu":
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
mode = "game"
def followork():
welcome()
s = sys.stdin.readline().strip()
if s.startswith("-l"):
for f in os.listdir("currentGoals/"):
if f.endswith(".txt"):
print (os.path.splitext(f)[0])
print
print "Which project would you like to choose?"
s = sys.stdin.readline().strip()
goal = Goal(s)
actions()
s1 = ""
while s1 != "quit":
s1 = sys.stdin.readline().strip()
if s1 == "add":
v = int(input())
goal.add(v)
print "Value added"
print
elif s1 == "addo":
d, v = sys.stdin.readline().split()
goal.add_otherDay(d, int(v))
print "Value added"
print
elif s1 == "show":
goal.statistics()
goal.plot()
elif s1 == "firstDay":
d = sys.stdin.readline().strip()
goal.set_firsday(d)
print "Date set."
print
def checkForStimulation (self, gp):
#check for stimulations
#left wall
if self.intersect (self.leftWall[0], self.leftWall[1], \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(self.leftWall[0], self.leftWall[1],\
self.startPoint, self.endPoint)[0])
self.wallStimulations.append(distance)
#right wall
elif self.intersect (self.rightWall[0], self.rightWall[1], \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(self.rightWall[0], self.rightWall[1],\
self.startPoint, self.endPoint)[0])
self.wallStimulations.append(distance)
#upper wall
elif self.intersect (self.upperWall[0], self.upperWall[1], \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(self.upperWall[0], self.upperWall[1],\
self.startPoint, self.endPoint)[0])
self.wallStimulations.append(distance)
else:
self.currentColor = self.sensorNeutralColor
self.wallStimulations.append(self.nonStimulated) #arbitrarily large num
#any player stimulations
encounteredPlayer = False #true if we encountered a player
for player in gp.playersNodes:
#the rect of the player
playerRect = pygame.Rect (player.getRect())
#bottom edge intersection
if self.intersect (playerRect.bottomleft, playerRect.bottomright, \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(playerRect.bottomleft, playerRect.bottomright,\
self.startPoint, self.endPoint)[0])
self.playerStimulations.append(distance)
encounteredPlayer = True
#left edge intersection
elif self.intersect (playerRect.topleft, playerRect.bottomleft, \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(playerRect.topleft, playerRect.bottomleft,\
self.startPoint, self.endPoint)[0])
self.playerStimulations.append(distance)
encounteredPlayer = True
#right edge intersection
elif self.intersect (playerRect.bottomright, playerRect.topright, \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(playerRect.bottomright, playerRect.topright,\
self.startPoint, self.endPoint)[0])
self.playerStimulations.append(distance)
encounteredPlayer = True
if not encounteredPlayer:
self.playerStimulations.append(self.nonStimulated) #arbitrarily large
#goal box stimulation
gRect = Goal.asRect() #for easier reference
#bottom boundary
if self.intersect (gRect.bottomleft, gRect.bottomright, \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(gRect.bottomleft, gRect.bottomright,\
self.startPoint, self.endPoint)[0])
self.goalStimulations.append(distance)
#left edge intersection
elif self.intersect (gRect.topleft, gRect.bottomleft, \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(gRect.topleft, gRect.bottomleft,\
self.startPoint, self.endPoint)[0])
self.goalStimulations.append(distance)
#right edge intersection
elif self.intersect (gRect.bottomright, gRect.topright, \
self.startPoint, self.endPoint) is not None:
self.currentColor = self.sensorStimulatedColor
distance = self.distance(self.getIntersect(gRect.bottomright, gRect.topright,\
self.startPoint, self.endPoint)[0])
self.goalStimulations.append(distance)
else:
self.goalStimulations.append(self.nonStimulated) #arbitrarily large num
#all the lists joined into one inputs
return self.wallStimulations + self.playerStimulations + self.goalStimulations
