def __init__(self, id, name=None, nextCapacityStationBufferId=None,**kw):
     Exit.__init__(self, id, name)
     self.isLocked=True
     self.nextCapacityStationBufferId=nextCapacityStationBufferId    # the id of the next station. If it is None it 
                                                                     # means it is the end of the system.
     self.nextCapacityStationBuffer=None                             # the next buffer. If it is None it
     from Globals import G
     G.CapacityStationExitList.append(self)
 def initialize(self):
     Exit.initialize(self)
     self.isLocked=True
     # list that contains the entities that are just obtained so that they can be 
     # moved to the next buffer
     self.currentlyObtainedEntities=[]
     # find the next buffer
     if self.nextCapacityStationBufferId:
         from Globals import G
         # find the project that the capacity entity is part of
         for capacityStationBuffer in G.CapacityStationBufferList:
             if capacityStationBuffer.id==self.nextCapacityStationBufferId:
                 self.nextCapacityStationBuffer=capacityStationBuffer
                 break
Exemple #3
0
def InstantiateRooms():
    global roomDictionary
    global currentRoom

    #Assign the dictionary of rooms its rooms' info.
    roomDictionary["room1"] = Room(
        "This is our first test room",
        [Exit("n", "room2"), Exit("e", "room3")])
    roomDictionary["room2"] = Room("You have made it to the second room.",
                                   [Exit("s", "room1")])
    roomDictionary["room3"] = Room("Third room lads lads lads lads",
                                   [Exit("w", "room1")])

    #Assign the starting room to be the current room
    currentRoom = roomDictionary['room1']
 def getEntity(self):
     activeEntity=Exit.getEntity(self)
     alreadyWorkedDict=activeEntity.capacityProject.alreadyWorkedDict   
     stationId=self.giver.id
     alreadyWorkedDict[stationId]+=activeEntity.requiredCapacity
     
     
Exemple #5
0
def main(argv=[], input_data=None):
    argv = argv or sys.argv[1:]

    #create an empty list to store all the objects in
    G.ObjList = []
    S = BatchSource('S1',
                    'Source',
                    interArrivalTime={'Fixed': {
                        'mean': 0.5
                    }},
                    item=Batch,
                    batchNumberOfUnits=100)
    E = Exit('E1', 'Exit')
    G.ObjList.append(S)
    G.ObjList.append(E)
    #     G.RouterList=[]
    if input_data is None:
        # user passes the topology filename as first argument to the program
        filename = argv[0]
        try:  # try to open the file with the inputs
            G.CMSDFile = open(
                filename, "r")  # global variable holding the file to be opened
        except IOError, IndexError:
            print "%s could not be open" % filename
            return "ERROR"
        G.InputData = G.CMSDFile.read(
        )  # pass the contents of the input file to the global var InputData
    def __init__(self, maze_filename):
        """Initialize the game manager object.

        Arguments:

        maze_filename - name of human readable/writable text file containing
            the maze definition for use in single player mode
        """

        gs = GameState.singleton()
        self.gs = gs

        gs.nickname = input(
            "For multiplayer game, enter your nickname (default is single player):"
        )
        if gs.nickname:
            gs.multiplayer = True
            # TODO - should be assigned by MazeServer
            while True:
                new_color_text = input(
                    f"Choose a color code ({', '. join(list(gs.colors()))}) (default is w):"
                )
                if not new_color_text:
                    break
                if new_color_text in gs.colors():
                    gs.color = gs.colors()[new_color_text]
                    break
                print(
                    f"Unknown color code: '{new_color_text}''. Please try again."
                )
            print(f"Selected {gs.color}.")
            gs.connection = MazeClient('127.0.0.1', 8089)
            gs.connection.Loop()
            # server will send the maze data
            while not gs.maze:
                gs.connection.Loop()
        else:
            gs.maze = Maze(maze_filename)

        # loop through maze file and instanciate the specified objects

        for i in range(0, gs.maze.height):
            for j in range(0, gs.maze.width):
                ch = gs.maze.file_rows[i][j]
                if ch == 'P':
                    gs.player = Player((i, j))
                elif ch == 'N' and not gs.multiplayer:
                    Npc((i, j))
                elif ch == 'E' and not gs.multiplayer:
                    Exit(gs.maze, (i, j))

        # boiler plate pygame initialization (screen just black after this)

        gs.camera = Camera()
Exemple #7
0
 def getEntity(self):
     activeEntity = Exit.getEntity(self)           #run the default method
     from Globals import G
     # for all the entities in the EntityList
     for entity in G.EntityList:
         requiredParts=entity.getRequiredParts()
         if requiredParts:
             # if the activeEntity is in the requierdParts of the entity
             if activeEntity in requiredParts:
                 # if the entity that requires the activeEntity can proceed then signal the currentStation of the entity
                 if entity.checkIfRequiredPartsReady() and entity.currentStation.expectedSignals['canDispose']:
                     self.sendSignal(receiver=entity.currentStation, signal=entity.currentStation.canDispose)
     return activeEntity
     
 def getEntity(self):
     activeEntity = Exit.getEntity(self)  #run the default method
     from Globals import G
     # for all the entities in the EntityList
     for entity in G.EntityList:
         requiredParts = entity.getRequiredParts()
         if requiredParts:
             # if the activeEntity is in the requierdParts of the entity
             if activeEntity in requiredParts:
                 # if the entity that requires the activeEntity can proceed then signal the currentStation of the entity
                 if entity.checkIfRequiredPartsReady(
                 ) and entity.currentStation.expectedSignals['canDispose']:
                     self.sendSignal(
                         receiver=entity.currentStation,
                         signal=entity.currentStation.canDispose)
     return activeEntity
Exemple #9
0
def example_simulation():
    
    size_scene = (100,100)#size_scene[0]==horizontal and size_scene[1]==vertical
    
    obstacles = [Obstacle((70,40),10,60),Obstacle((20,50),50,10),Obstacle((30,10),10,40)]
    
    exits = [Exit((85,99),10,2)]

    # warning, the size must be chosen as an integer, agent.size*precision must preferably be an integer to improve speed
    agents = [Agent((10,90),1),Agent((10,80),1),Agent((10,70),1),Agent((10,60),2),Agent((10,50),2),Agent((10,40),2)
              ,Agent((10,30),2),Agent((10,20),2),Agent((10,10),2),Agent((14,90),2),Agent((14,80),2),Agent((14,70),2)
              ,Agent((14,60),2),Agent((14,50),2),Agent((14,40),2),Agent((14,30),2),Agent((14,20),2),Agent((14,10),4)
              ]

    time_simulation = 40 #in seconds
    dt = .1 # in seconds

    launch_simulation(size_scene,obstacles,exits,agents,time_simulation,dt)
Exemple #10
0
def create_exit_objects():
    '''
    This function will create exit objects from a read file
    and return a nested list
    '''
    # Declare Variables
    exit_list = []

    # Reading files and combining lists
    contents = read_file('Exit Table1.csv')
    contents2 = read_file('Exit Table2.csv')
    contents3 = read_file('Exit Table3.csv')
    contents.extend(contents2)
    contents.extend(contents3)

    # Create Client Objects
    for x in range(0, len(contents)):
        exit_list.append(
            Exit(contents[x][0], contents[x][1], contents[x][2],
                 contents[x][3], contents[x][4], contents[x][5],
                 contents[x][6]))
    return exit_list
agents.append(agent1)
agents.append(agent2)

obstacles = []
obstacle1 = Obstacle((-2, 2), 4, 1)
obstacle2 = Obstacle((4, 0), 1, 4)
obstacle3 = Obstacle((-4, -3), 3, 1)
obstacle4 = Obstacle((-2, 4), 1, 2)

#obstacles.append(obstacle1)
#obstacles.append(obstacle2)
#obstacles.append(obstacle3)
#obstacles.append(obstacle2)

exits = []
exit1 = Exit((4, 4), 2, 2)
#exits.append(exit1)

agent1.update_position(agents, obstacles, exits, 1, (10, 10))
agent2.update_position(agents, obstacles, exits, 1, (10, 10))

for obstacle in obstacles:
    ax1.add_patch(
        patches.Rectangle(obstacle.position, obstacle.width, obstacle.height))

for exit in exits:
    ax1.add_patch(patches.Rectangle(exit.position, exit.width, exit.height))

for agent in agents:
    print agent
    colour = agent.get_color_agent()
Exemple #12
0
import variables, graphics, enemies
from enemies import enemyforspecialbattle
from conversations import getconversation
from mapsvars import *
from graphics import snowland
from Exit import Exit
from Rock import Rock
from pygame import Rect

# snowentrance###########################################################################
snowentrance = Map(snowland(650, 500, True), [])
snowentrance.populate_with("snowpinetree", randint(4, 10))

snowentrance.exitareas = [
    Exit("right", False, "jeremyhome", "left", "same"),
    Exit("left", False, "snowarea1", "right", "same")
]
snowentrance.enemies = enemies.snowenemies
snowentrance.lvrange = [6]

# snowarea1##############################################################################
snowarea1 = Map(snowland(700, 500), [])
snowarea1.populate_with("snowpinetree", randint(10, 15))

snowarea1.lvrange = [6, 7]
snowarea1.enemies = enemies.snowenemies

snowarea1.exitareas = [
    Exit("right", False, "snowentrance", "left", "same"),
    Exit("left", False, "hoppingtreearea", "right", "same")
 def initialize(self):
     from Globals import G
     self.previous = G.ObjList
     Exit.initialize(self)  #run default behaviour
Exemple #14
0
 def canAccept(self, callerObject=None):
     if self.isLocked:
         return False
     return Exit.canAccept(self)
Exemple #15
0
],
                shadowsp=False)

eatfromstash = Conversation("eatfromstash", [],
                            speaksafter=[[], [], [], [], [], [], [], [],
                                         [getconversation("hungryspeak")]],
                            switchtheserocks="stash")

eatfromstashoffset = 10
eatfromstash.area = [
    131 + eatfromstashoffset, 61, GR["stash00"]["w"] - 2 * eatfromstashoffset,
    GR["stash00"]["h"]
]

doorexit = Exit([35 + honeyw / 2, 165, 37 - honeyw, extraarea], True,
                'outside1', GR["honeyhouseoutside"]["w"] * 0.3 + houserock.x,
                GR["honeyhouseoutside"]["h"] - honeyh + honeyfeetheight -
                20 * p)
doorexit.eventrequirements = [EventRequirement("letter")]

blockexit = getconversation("hungry")
blockexit.area = doorexit.area
blockexit.eventrequirements = [EventRequirement("letter", -1, 1)]

honeyhome.conversations = [eatfromstash, blockexit]

honeyhome.startpoint = [28, 39]

letterexit = Exit([67, 100, 20, 30], True, 'letter',
                  GR["paper"]['w'] * (3 / 10), 0)
letterexit.storyevent = "letter"
def readResources():
    G.SourceList = []
    G.MachineList = []
    G.ExitList = []
    G.QueueList = []
    G.RepairmanList = []
    G.AssemblyList = []
    G.DismantleList = []
    G.ConveyerList = []

    resource = (G.CMSDData.getElementsByTagName('Resource'))

    #this loop will search in all the objects for repairmen and create them.
    #repairmen have to be created first since they may be used in the creation of the other objects
    for i in range(len(resource)):
        #get the class
        try:
            resourceClass = resource[i].getElementsByTagName(
                'ResourceClassIdentifier')
            resourceClass = resourceClass[0].toxml().replace(
                '<ResourceClassIdentifier>',
                '').replace('</ResourceClassIdentifier>', '')
        except IndexError:
            continue

        if resourceClass == 'Repairman':
            id = resource[i].getElementsByTagName('Identifier')
            id = id[0].toxml().replace('<Identifier>',
                                       '').replace('</Identifier>', '')
            name = resource[i].getElementsByTagName('Name')
            name = name[0].toxml().replace('<Name>', '').replace('</Name>', '')
            property = resource[i].getElementsByTagName('Property')
            for j in range(len(property)):
                propertyName = property[j].getElementsByTagName('Name')
                propertyName = propertyName[0].toxml().replace(
                    '<Name>', '').replace('</Name>', '')
                if propertyName == 'capacity':
                    capacity = property[j].getElementsByTagName('Value')
                    capacity = int(capacity[0].toxml().replace(
                        '<Value>', '').replace('</Value>', ''))

            R = Repairman(id, name, capacity)
            G.RepairmanList.append(R)

    for i in range(len(resource)):
        #get the class
        try:
            resourceClass = resource[i].getElementsByTagName(
                'ResourceClassIdentifier')
            resourceClass = resourceClass[0].toxml().replace(
                '<ResourceClassIdentifier>',
                '').replace('</ResourceClassIdentifier>', '')
        except IndexError:
            continue

        if resourceClass == 'Source':
            id = resource[i].getElementsByTagName('Identifier')
            id = id[0].toxml().replace('<Identifier>',
                                       '').replace('</Identifier>', '')
            name = resource[i].getElementsByTagName('Name')
            name = name[0].toxml().replace('<Name>', '').replace('</Name>', '')
            property = resource[i].getElementsByTagName('Property')
            for j in range(len(property)):
                propertyName = property[j].getElementsByTagName('Name')
                propertyName = propertyName[0].toxml().replace(
                    '<Name>', '').replace('</Name>', '')
                if propertyName == 'partType':
                    partType = property[j].getElementsByTagName('Value')
                    partType = (partType[0].toxml().replace(
                        '<Value>', '').replace('</Value>', ''))
                    entity = str_to_class(partType)
                elif propertyName == 'interarrivalTime':
                    unit = property[j].getElementsByTagName('Unit')
                    unit = unit[0].toxml().replace('<Unit>',
                                                   '').replace('</Unit>', '')
                    distribution = property[j].getElementsByTagName(
                        'Distribution')
                    distributionType = distribution[0].getElementsByTagName(
                        'Name')
                    distributionType = distributionType[0].toxml().replace(
                        '<Name>', '').replace('</Name>', '')
                    distributionParameter = distribution[
                        0].getElementsByTagName('DistributionParameter')
                    distributionParameterName = distributionParameter[
                        0].getElementsByTagName('Name')
                    distributionParameterName = distributionParameterName[
                        0].toxml().replace('<Name>',
                                           '').replace('</Name>', '')
                    mean = distributionParameter[0].getElementsByTagName(
                        'Value')
                    mean = float(mean[0].toxml().replace('<Value>',
                                                         '').replace(
                                                             '</Value>', ''))

            S = Source(id, name, distributionType, mean, entity)
            G.SourceList.append(S)
            G.ObjList.append(S)

        elif resourceClass == 'Machine':
            id = resource[i].getElementsByTagName('Identifier')
            id = id[0].toxml().replace('<Identifier>',
                                       '').replace('</Identifier>', '')
            name = resource[i].getElementsByTagName('Name')
            name = name[0].toxml().replace('<Name>', '').replace('</Name>', '')
            property = resource[i].getElementsByTagName('Property')
            for j in range(len(property)):
                propertyName = property[j].getElementsByTagName('Name')
                propertyName = propertyName[0].toxml().replace(
                    '<Name>', '').replace('</Name>', '')
                if propertyName == 'ProcessTime':
                    unit = property[j].getElementsByTagName('Unit')
                    unit = unit[0].toxml().replace('<Unit>',
                                                   '').replace('</Unit>', '')
                    distribution = property[j].getElementsByTagName(
                        'Distribution')
                    distributionType = distribution[0].getElementsByTagName(
                        'Name')
                    distributionType = distributionType[0].toxml().replace(
                        '<Name>', '').replace('</Name>', '')
                    distributionParameter = distribution[
                        0].getElementsByTagName('DistributionParameter')
                    mean = 0
                    stdev = 0
                    min = 0
                    max = 0
                    availability = 0
                    failureDistribution = None
                    for k in range(len(distributionParameter)):
                        distributionParameterName = distributionParameter[
                            0].getElementsByTagName('Name')
                        distributionParameterName = distributionParameterName[
                            0].toxml().replace('<Name>',
                                               '').replace('</Name>', '')
                        if distributionParameterName == 'mean':
                            mean = distributionParameter[
                                0].getElementsByTagName('Value')
                            mean = float(mean[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                        elif distributionParameterName == 'stdev':
                            stdev = distributionParameter[
                                0].getElementsByTagName('Value')
                            stdev = float(stdev[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                        elif distributionParameterName == 'min':
                            min = distributionParameter[
                                0].getElementsByTagName('Value')
                            min = float(mean[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                        elif distributionParameterName == 'max':
                            max = distributionParameter[
                                0].getElementsByTagName('Value')
                            max = float(mean[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                elif propertyName == 'MeanTimeToFailure':
                    unit = property[j].getElementsByTagName('Unit')
                    unit = unit[0].toxml().replace('<Unit>',
                                                   '').replace('</Unit>', '')
                    distribution = property[j].getElementsByTagName(
                        'Distribution')
                    failureDistribution = distribution[0].getElementsByTagName(
                        'Name')
                    failureDistribution = failureDistribution[0].toxml(
                    ).replace('<Name>', '').replace('</Name>', '')
                    distributionParameter = distribution[
                        0].getElementsByTagName('DistributionParameter')
                    for k in range(len(distributionParameter)):
                        distributionParameterName = distributionParameter[
                            0].getElementsByTagName('Name')
                        distributionParameterName = distributionParameterName[
                            0].toxml().replace('<Name>',
                                               '').replace('</Name>', '')
                        if distributionParameterName == 'mean':
                            MTTF = distributionParameter[
                                0].getElementsByTagName('Value')
                            MTTF = float(MTTF[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                        elif distributionParameterName == 'availability':
                            availability = distributionParameter[
                                0].getElementsByTagName('Value')
                            availability = (availability[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                elif propertyName == 'MeanTimeToRepair':
                    unit = property[j].getElementsByTagName('Unit')
                    unit = unit[0].toxml().replace('<Unit>',
                                                   '').replace('</Unit>', '')
                    distribution = property[j].getElementsByTagName(
                        'Distribution')
                    failureDistribution = distribution[0].getElementsByTagName(
                        'Name')
                    failureDistribution = failureDistribution[0].toxml(
                    ).replace('<Name>', '').replace('</Name>', '')
                    distributionParameter = distribution[
                        0].getElementsByTagName('DistributionParameter')
                    for k in range(len(distributionParameter)):
                        distributionParameterName = distributionParameter[
                            0].getElementsByTagName('Name')
                        distributionParameterName = distributionParameterName[
                            0].toxml().replace('<Name>',
                                               '').replace('</Name>', '')
                        if distributionParameterName == 'mean':
                            MTTR = distributionParameter[
                                0].getElementsByTagName('Value')
                            MTTR = float(MTTR[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                        elif distributionParameterName == 'availability':
                            availability = distributionParameter[
                                0].getElementsByTagName('Value')
                            availability = (availability[0].toxml().replace(
                                '<Value>', '').replace('</Value>', ''))
                elif propertyName == 'RepairmanRequired':
                    repairmanID = property[j].getElementsByTagName(
                        'ResourceIdentifier')
                    repairmanID = (repairmanID[0].toxml().replace(
                        '<ResourceIdentifier>',
                        '').replace('</ResourceIdentifier>', ''))
                    if repairmanID == 'None':
                        repairman = repairmanID
                    else:
                        for j in range(len(G.RepairmanList)):
                            if (G.RepairmanList[j].id == repairmanID):
                                repairman = G.RepairmanList[j]

            M = Machine(id,
                        name,
                        1,
                        distribution=distributionType,
                        failureDistribution=failureDistribution,
                        MTTF=MTTF,
                        MTTR=MTTR,
                        availability=availability,
                        repairman=repairman,
                        mean=mean,
                        stdev=stdev,
                        min=min,
                        max=max)
            G.MachineList.append(M)
            G.ObjList.append(M)

        elif resourceClass == 'Queue':
            id = resource[i].getElementsByTagName('Identifier')
            id = id[0].toxml().replace('<Identifier>',
                                       '').replace('</Identifier>', '')
            name = resource[i].getElementsByTagName('Name')
            name = name[0].toxml().replace('<Name>', '').replace('</Name>', '')
            property = resource[i].getElementsByTagName('Property')
            isDummy = 0
            capacity = 2
            for j in range(len(property)):
                propertyName = property[j].getElementsByTagName('Name')
                propertyName = propertyName[0].toxml().replace(
                    '<Name>', '').replace('</Name>', '')
                if propertyName == 'capacity':
                    capacity = property[j].getElementsByTagName('Value')
                    capacity = int(capacity[0].toxml().replace(
                        '<Value>', '').replace('</Value>', ''))
                if propertyName == 'isDummy':
                    capacity = property[j].getElementsByTagName('Value')
                    capacity = int(capacity[0].toxml().replace(
                        '<Value>', '').replace('</Value>', ''))
            Q = Queue(id, name, capacity, isDummy)
            G.QueueList.append(Q)
            G.ObjList.append(Q)

        elif resourceClass == 'Exit':
            id = resource[i].getElementsByTagName('Identifier')
            id = id[0].toxml().replace('<Identifier>',
                                       '').replace('</Identifier>', '')
            name = resource[i].getElementsByTagName('Name')
            name = name[0].toxml().replace('<Name>', '').replace('</Name>', '')
            E = Exit(id, name)
            G.ExitList.append(E)
            G.ObjList.append(E)
Exemple #17
0
 def initialize(self):
     from Globals import G
     self.previous=G.ObjList
     Exit.initialize(self)   #run default behaviour
     
                 table,
                 littleletter,
                 Rock(stashlist, 131, 55, [0, 0.9, 1, 0.1], name="stash")],
                shadowsp = False)

eatfromstash = Conversation("eatfromstash",
                            [],
                            speaksafter = [[],[],[],[],[],[],[],[],
                                           [getconversation("hungryspeak")]],
                            switchtheserocks="stash")

eatfromstashoffset = 10
eatfromstash.area = [131+eatfromstashoffset, 61, GR["stash00"]["w"]-2*eatfromstashoffset, GR["stash00"]["h"]]

doorexit = Exit([35 + honeyw / 2, 165, 37 - honeyw, extraarea],
                True, 'outside1',
                GR["honeyhouseoutside"]["w"] * 0.3 + houserock.x, GR["honeyhouseoutside"]["h"] - honeyh + honeyfeetheight-20*p)
doorexit.eventrequirements = [EventRequirement("letter")]

blockexit = getconversation("hungry")
blockexit.area = doorexit.area
blockexit.eventrequirements = [EventRequirement("letter", -1, 1)]

honeyhome.conversations = [eatfromstash, blockexit]

honeyhome.startpoint = [28, 39]

letterexit = Exit([67, 100, 20, 30],
                  True, 'letter',
                  GR["paper"]['w']*(3/10), 0)
letterexit.storyevent = "letter"
Exemple #19
0
from Source import Source
from Exit import Exit
from Part import Part
from Queue import Queue
from Globals import G
import ExcelHandler
import Globals

G.trace = "Yes"

S = Source('S1', 'Source', mean=1, item=Part)
M1 = Machine('M1', 'Machine1', mean=0.75)
Q1 = Queue('Q1', 'Queue1', capacity=infinity)
M2 = Machine('M2', 'Machine2', mean=0.75)
Q2 = Queue('Q2', 'Queue2', capacity=infinity)
E = Exit('E1', 'Exit')

#define predecessors and successors for the objects
S.defineRouting([M1])
M1.defineRouting([S], [Q1])
Q1.defineRouting([M1], [M2])
M2.defineRouting([Q1], [Q2])
Q2.defineRouting([M2])

argumentDict = {'from': 'Q2', 'to': 'E1', 'safetyStock': 70, 'consumption': 20}
EG = EventGenerator(id="EV",
                    name="ExcessEntitiesMover",
                    start=60,
                    interval=60,
                    method=Globals.moveExcess,
                    argumentDict=argumentDict)
Exemple #20
0
 def outputResultsJSON(self):
     # output results only for the last exit
     if not self.nextCapacityStationBuffer:
         Exit.outputResultsJSON(self)
from Location import Location
from Exit import Exit
from Player import Player
import random

room1 = Location(["cheese", "tree", "monkey"], ["north"], "room 1")
room2 = Location(["plant", "painting"], ["south"], "room 2")

exit1 = Exit()

room1.printAttributes()
room2.printAttributes()

player1 = Player()

player1.printAttributes()

while player1.room == room1:

    print "game loop active"
    player1.playerReply()

    player1.printAttributes()
    room1.printAttributes()
def main(simulation):
    controller = Controller(168)

    machine_transitions = calculate_machine_probs()
    waste_probs = calculate_waste_probs()

    entry = Entry("Recibidor", exponential, [5.108333], gamma, [0.913, 2380])
    reception = Queue("Recepcion")
    machine = MachineStation("Maquina", fixed, [0], machine_transitions)

    machine_waste = Exit("Descarte maquina")
    band_12 = Queue("Banda 12")
    band_14 = Queue("Banda 14")
    band_16 = Queue("Banda 16")
    band_18 = Queue("Banda 18")
    band_20 = Queue("Banda 20")
    band_22 = Queue("Banda 22")
    band_24 = Queue("Banda 24")
    band_26 = Queue("Banda 26")
    band_28 = Queue("Banda 28")
    band_30 = Queue("Banda 30")
    band_32 = Queue("Banda 32")

    cali_12 = Station("Calibre 12", fixed, [0.002318],
                      [waste_probs[12], 1 - waste_probs[12]])
    cali_14 = Station("Calibre 14", fixed, [0.002318],
                      [waste_probs[14], 1 - waste_probs[14]])
    cali_16 = Station("Calibre 16", fixed, [0.002318],
                      [waste_probs[16], 1 - waste_probs[16]])
    cali_18 = Station("Calibre 18", fixed, [0.002318],
                      [waste_probs[18], 1 - waste_probs[18]])
    cali_20 = Station("Calibre 20", fixed, [0.002031],
                      [waste_probs[20], 1 - waste_probs[20]])
    cali_22 = Station("Calibre 22", fixed, [0.000924],
                      [waste_probs[22], 1 - waste_probs[22]])
    cali_24 = Station("Calibre 24", fixed, [0.004010],
                      [waste_probs[24], 1 - waste_probs[24]])
    cali_26 = Station("Calibre 26", fixed, [0.001590],
                      [waste_probs[26], 1 - waste_probs[26]])
    cali_28 = Station("Calibre 28", fixed, [0.002643],
                      [waste_probs[28], 1 - waste_probs[28]])
    cali_30 = Station("Calibre 30", fixed, [0.006250],
                      [waste_probs[30], 1 - waste_probs[30]])
    cali_32 = Station("Calibre 32", fixed, [0.016444],
                      [waste_probs[32], 1 - waste_probs[32]])

    descarte_12 = Exit("Descarte 12")
    descarte_14 = Exit("Descarte 14")
    descarte_16 = Exit("Descarte 16")
    descarte_18 = Exit("Descarte 18")
    descarte_20 = Exit("Descarte 20")
    descarte_22 = Exit("Descarte 22")
    descarte_24 = Exit("Descarte 24")
    descarte_26 = Exit("Descarte 26")
    descarte_28 = Exit("Descarte 28")
    descarte_30 = Exit("Descarte 30")
    descarte_32 = Exit("Descarte 32")

    wait_small_p = Queue("Espera palet pequeño")
    wait_big_p = Queue("Espera palet grande")

    palet_peque = PaletStation("Palet pequeño", fixed, [0], 980)
    palet_grande = PaletStation("Palet grande", fixed, [0], 1180)

    cold_room = Queue("Cuarto frio")
    dispacher = Station("Despachador", exponential, [92.52], [1])
    exit = Exit("Salida")

    entry.connect_with(reception)
    reception.connect_with(machine)

    machine.connect_with(band_12)
    machine.connect_with(band_14)
    machine.connect_with(band_16)
    machine.connect_with(band_18)
    machine.connect_with(band_20)
    machine.connect_with(band_22)
    machine.connect_with(band_24)
    machine.connect_with(band_26)
    machine.connect_with(band_28)
    machine.connect_with(band_30)
    machine.connect_with(band_32)
    machine.connect_with(machine_waste)

    band_12.connect_with(cali_12)
    band_14.connect_with(cali_14)
    band_16.connect_with(cali_16)
    band_18.connect_with(cali_18)
    band_20.connect_with(cali_20)
    band_22.connect_with(cali_22)
    band_24.connect_with(cali_24)
    band_26.connect_with(cali_26)
    band_28.connect_with(cali_28)
    band_30.connect_with(cali_30)
    band_32.connect_with(cali_32)

    cali_12.connect_with(descarte_12)
    cali_14.connect_with(descarte_14)
    cali_16.connect_with(descarte_16)
    cali_18.connect_with(descarte_18)
    cali_20.connect_with(descarte_20)
    cali_22.connect_with(descarte_22)
    cali_24.connect_with(descarte_24)
    cali_26.connect_with(descarte_26)
    cali_28.connect_with(descarte_28)
    cali_30.connect_with(descarte_30)
    cali_32.connect_with(descarte_32)

    cali_12.connect_with(wait_big_p)
    cali_14.connect_with(wait_big_p)
    cali_16.connect_with(wait_big_p)
    cali_18.connect_with(wait_big_p)
    cali_20.connect_with(wait_big_p)
    cali_22.connect_with(wait_big_p)
    cali_24.connect_with(wait_small_p)
    cali_26.connect_with(wait_small_p)
    cali_28.connect_with(wait_small_p)
    cali_30.connect_with(wait_small_p)
    cali_32.connect_with(wait_small_p)

    wait_small_p.connect_with(palet_peque)
    wait_big_p.connect_with(palet_grande)

    palet_peque.connect_with(cold_room)
    palet_grande.connect_with(cold_room)

    cold_room.connect_with(dispacher)
    dispacher.connect_with(exit)

    entry.execute(None)
    controller.start_simulation()

    print("simulation %d finished" % simulation)

    queues = [
        band_12, band_14, band_16, band_18, band_20, band_22, band_24, band_26,
        band_28, band_30, band_32
    ]

    exits = [
        machine_waste, descarte_12, descarte_14, descarte_16, descarte_18,
        descarte_20, descarte_22, descarte_24, descarte_26, descarte_28,
        descarte_30, descarte_32, exit
    ]

    stations = [
        palet_peque, palet_grande, cali_12, cali_14, cali_16, cali_18, cali_20,
        cali_22, cali_24, cali_26, cali_28, cali_30, cali_32
    ]

    data_queue = []
    for queue in queues:
        name, items, lenght, max_wait, min_wait, avg_wait = queue.get_info()
        data_queue.append([simulation, name, max_wait, avg_wait])

    data_exit = []
    for exit in exits:
        name, kg = exit.get_info()
        data_exit.append([simulation, name, kg])

    data_station = []
    for station in stations:
        name, kg = station.get_info()
        data_station.append([simulation, name, kg])

    return data_queue, data_exit, data_station
Exemple #23
0
              b * 5 - GR["rabbithole"]["h"], [0, 3 / 4, 1, 1 / 4])
jmyman.background_range = hole.background_range.copy()

dancelionanim = Animation(["dancelion0", "dancelion1"], (60000 / 130) * 2)
dancelion = Rock(dancelionanim, b / 2, b * 4, [0, 3 / 4, 1, 1 / 4])
dancelion.updatealways = True

jeremyhome = Map(rgrassland, [hole, jmyman, dancelion])

dontputrockslist = [dancelion.getrect(), jmyman.getrect()]
jeremyhome.populate_with("greyrock", randint(0, 2), dontputrockslist)
jeremyhome.populate_with("pinetree", randint(3, 8), dontputrockslist)
jeremyhome.populate_with("flower", randint(15, 25), dontputrockslist)

jeremyhome.exitareas = [
    Exit("right", False, 'outside1', "left", "same"),
    Exit("left", False, 'snowentrance', "right", "same")
]
jeremy = getconversation("jeremy")
jeremy.area = [
    b * 5 + GR["rabbithole"]["w"] - (honeyw / 2),
    b * 5 - GR["rabbithole"]["h"], GR["rabbithole"]["w"] - (honeyw / 2),
    GR["rabbithole"]["h"]
]
jeremy.eventrequirements = [EventRequirement("beatsteve", -1, 1)]

jeremyaftersteve = getconversation("jeremyaftersteve")
jeremyaftersteve.area = jeremy.area.copy()
jeremyaftersteve.eventrequirements = [EventRequirement("beatsteve")]

dancelionpass = getconversation("dancelionpass")
Exemple #24
0
	def __init__(self, roomJson):
		import threading
		from Exit import Exit
		import Engine.RoomEngine
		from Inventory.RoomInventory import RoomInventory
		from SpawnTemplate import SpawnTemplate
		
		EventReceiver.__init__(self)
		
		attributes = {
			'playerSemaphore'	: threading.BoundedSemaphore(1),
			'roomID'			: '',
			'name'				: '',
			'description'		: [],
			'exits'				: [],
			'players'			: [],
			'npcs'				: [],
			'spawnableNPCs'		: [],
			'inventory'			: None,
			'spawnTemplates'	: []
		}
		
		out_adjusters	= []
		inventory		= None
		spawnTemplates	= None
		
		for key in attributes.keys():
			self.attributes[key] = attributes[key]
			
		for key in roomJson.keys():
			if key == 'exits':
				for exitJson in roomJson[key]:
					exit = Exit()
					for field in exitJson.keys():
						exit.attributes[field] = exitJson[field]
					
					self.attributes[key].append(exit)
			elif key == 'eventHandlers':
				for element in roomJson[key]:
					adjusters = (lambda dictionary: dictionary.has_key('adjusters') and dictionary['adjusters'] or None)(element)
					
					self.addEventHandlerByNameWithAdjusters(element['name'], adjusters)
			elif key == 'inventory':
				inventory = roomJson[key]
			elif key == 'spawnTemplates':
				spawnTemplates = roomJson[key]
			elif key == 'out_adjusters':
				out_adjusters = roomJson[key]
			else:
				self.attributes[key] = roomJson[key]
		
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ActorAttemptedMovementEventHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ActorMovedFromRoomEventHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ActorAddedToRoomEventHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ActorObservedHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.WasObservedHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ActorEmotedHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.PlayerLogoutHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.SpellCastAttempted', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ActorAttemptedItemGrabHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ActorGrabbedItemHandler', None)
		self.addEventHandlerByNameWithAdjusters('Environment.EventHandlers.Room.ItemDroppedHandler', None)
		
		Engine.RoomEngine.addEventSubscriber(self)
		
		EventEmitter.__init__(self, out_adjusters)
		
		if inventory != None:
			self.attributes['inventory'] = RoomInventory(inventory, self)
		else:
			self.attributes['inventory'] = RoomInventory(None, self)
			
		if spawnTemplates != None:
			for template in spawnTemplates:
				spawnTemplate = SpawnTemplate(template, self)
					
				self.attributes['spawnTemplates'].append(spawnTemplate)
Exemple #25
0
honeyh = GR["honeyside0"]["h"]
extraarea = 50
print(variables.width)

# outside2##############################################################################################################
b = GR["leftturn"]["w"]
outsideheight = GR["leftturn"]["h"]
outside2 = Map(GR["leftturn"], [Rock(GR["talltree"], 4*b, 5*b, True),
                                Rock(GR["talltree"], 5.5*b, 4.5*b, True),
                                Rock(GR["talltree"], 2*b, 4.7*b, True),
                                Rock(GR["talltree"], 6.7*b, 2*b, True),
                                Rock(GR["rock"], 5*b, 4*b, False),
                                Rock(GR["talltree"], 1.7*b, 0.3*b, True),
                                Rock(GR["rock"], 6*b, 2*b, True)])

outside2.exitareas = [Exit([-extraarea, 0, extraarea, outsideheight], False, 'outside1', GR["horizontal"]["w"] - honeyw, "same")]
outside2.enemies = [Enemy(GR["sheep0"], 0.5, "sheep"), Enemy(GR["meangreen0"], 0.3, "greenie"), Enemy(GR["purpleperp0"], 0.2, "purpur")]
outside2.lvrange = [1]

# jeremyhome############################################################################################################
b = GR["halfpath"]["w"] / 10

jeremyhome = Map(GR["horizontal"],
                 [Rock(GR["rabbithole"], b * 5 + GR["rabbithole"]["w"], b * 5 - GR["rabbithole"]["h"], True),
                  Rock(GR["jeremy0"], b * 5 + GR["rabbithole"]["w"], b * 5 - GR["rabbithole"]["h"], True)])
jeremyhome.exitareas = [Exit([b * 10, 0, extraarea, GR["halfpath"]["h"]], False, 'outside1', 0, "same")]
conversations.jeremy.area = [b * 5 + GR["rabbithole"]["w"]-(honeyw/2), b * 5 - GR["rabbithole"]["h"],
                             GR["rabbithole"]["w"]-(honeyw/2), GR["rabbithole"]["h"]]
jeremyhome.conversations = [conversations.jeremy]

# outside1##############################################################################################################