import sim.engine.Steppable; //导入依赖的package包/类
@Override
public void start(FishState model) {
    Preconditions.checkArgument(receipt == null, "already started, love");


    //start all tiles
    for(Object element : rasterBackingGrid.elements())
    {
        SeaTile tile = (SeaTile) element; //cast
        tile.start(model);
    }

    Preconditions.checkArgument(receipt==null);
    //reset fished map count
    receipt =
            model.scheduleEveryDay(new Steppable() {
                @Override
                public void step(SimState simState) {
                    dailyTrawlsMap.setTo(0);
                }
            },StepOrder.DAWN);

}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 * will step this object only once when the specific year starts. If that year is in the past, it won't step.
 * Implementation wise unfortunately I just check every year to see whether to step this or not. It's quite silly.
 * @param steppable
 * @param order
 * @param year
 */
public Stoppable scheduleOnceAtTheBeginningOfYear(Steppable steppable,StepOrder order, int year)
{

    final Steppable container = new Steppable() {
        @Override
        public void step(SimState simState) {
            //the plus one is because when this is stepped it's the 365th day
            if(((FishState) simState).getYear()+1 == year) {
                steppable.step(simState);
            }

        }
    };
    return scheduleEveryYear(container,order);

}
 

import sim.engine.Steppable; //导入依赖的package包/类
public Stoppable schedulePerPolicy(Steppable steppable, StepOrder order, IntervalPolicy policy)
{
    switch (policy){
        case EVERY_STEP:
            return scheduleEveryStep(steppable,order);
        case EVERY_DAY:
            return scheduleEveryDay(steppable,order);
        case EVERY_MONTH:
            return scheduleEveryXDay(steppable,order,30);
        case EVERY_YEAR:
            return scheduleEveryYear(steppable, order);
        default:
            Preconditions.checkState(false,"Reset Policy not found");
    }

    return null;
}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 * Applies this function to the given argument.
 *
 * @param fishState the function argument
 * @return the function result
 */
@Override
public ExternalOpenCloseSeason apply(FishState fishState) {
    return locker.presentKey
            (fishState,
             new Supplier<ExternalOpenCloseSeason>() {
                 @Override
                 public ExternalOpenCloseSeason get() {
                     ExternalOpenCloseSeason toReturn = new ExternalOpenCloseSeason();

                     fishState.scheduleEveryXDay(new Steppable() {
                         @Override
                         public void step(SimState simState) {
                             toReturn.setOpen(fishState.getRandom().nextBoolean());
                         }
                     }, StepOrder.POLICY_UPDATE,30);

                     return toReturn;
                 }
             });

}
 

import sim.engine.Steppable; //导入依赖的package包/类
@Override
public void start(FishState model, Fisher fisher) {

    //shedule yourself to check for profits every year
    if(stoppable != null)
        throw  new RuntimeException("Already started!");

    Steppable steppable = new Steppable() {
        @Override
        public void step(SimState simState) {
            checkIfQuit(fisher);
        }
    };
    this.stoppable = model.scheduleEveryYear(steppable, StepOrder.DAWN);
    decorated.start(model,fisher);

}
 

import sim.engine.Steppable; //导入依赖的package包/类
@Override
public void start() {
   super.start();
   initSeries();
   
   scheduleRepeatingImmediatelyAfter(new Steppable() {
      private static final long serialVersionUID = 1L;
      private int lastCycleIndex   = 0;
      
      @Override
      public void step(final SimState state) {
         final AbstractModel model = (AbstractModel) state;
         final int currentCycleIndex = (int) Simulation.getFloorTime();
         
         if (model.schedule.getTime() != Schedule.AFTER_SIMULATION
             && currentCycleIndex != lastCycleIndex) {
            scheduleSeries(model);
            lastCycleIndex = currentCycleIndex;
         }
      }
   });
}
 

import sim.engine.Steppable; //导入依赖的package包/类
public RecordingTestModel(long seed) {
    super(seed);
    
    for (int i = 0; i < agentNum; i++) {
        RecordingTestAgent recordingTestAgent = new RecordingTestAgent(i);
        agentList.add(recordingTestAgent);
        anonymList.add(recordingTestAgent);
    }
    
    schedule.scheduleRepeating(
        new Steppable() {
            private static final long
                serialVersionUID = 1023983258758828337L;
            
            @Override
            public void step(SimState state) {
                someDouble = state.schedule.getTime();
                intList.add((int) Math.round(someDouble));
            }
        }, 
        1);
}
 

import sim.engine.Steppable; //导入依赖的package包/类
@Override
public void addSteppables() {
	Steppable manager = (Steppable) this.getScenario().getProperties().get("ManagerAgent");
	try {
		this.registerShanksAgent((ShanksAgent) manager);
	} catch (ShanksException e) {
		logger.severe(e.getMessage());
		System.exit(1);
	}
	schedule.scheduleRepeating(Schedule.EPOCH, 3, manager, 1);
	Steppable generator = new DiagnosisCaseGenerator(this.getScenario().getProperties()
			.getProperty(SimulationConfiguration.TESTDATASET), this.getLogger());
	schedule.scheduleRepeating(Schedule.EPOCH, 6, generator, 1);
	boolean repMode = new Boolean(this.getScenario().getProperties()
			.getProperty(SimulationConfiguration.REPUTATIONMODE));
	Steppable evaluator = new DiagnosisCaseEvaluator(this.getScenario().getProperties()
			.getProperty(SimulationConfiguration.CLASSIFICATIONTARGET), this.getScenario()
			.getProperties().getProperty(SimulationConfiguration.EXPOUTPUT), this.getScenario()
			.getProperties().getProperty(SimulationConfiguration.TESTDATASET), repMode, this.getLogger());
	schedule.scheduleRepeating(Schedule.EPOCH, 5, evaluator, 1);
}
 

import sim.engine.Steppable; //导入依赖的package包/类
private void setupProduction(final Firm seller) {
    sellerToInflowMap.put(seller,inflowPerSeller);
    getModel().scheduleSoon(ActionOrder.PRODUCTION,new Steppable() {
        @Override
        public void step(SimState simState) {
            if(destroyUnsoldInventoryEachDay)
                seller.consumeAll();

            //sell 4 goods!
            int inflow = sellerToInflowMap.get(seller);
            seller.receiveMany(UndifferentiatedGoodType.GENERIC,inflow);
            seller.reactToPlantProduction(UndifferentiatedGoodType.GENERIC,inflow);

            //every day
            getModel().scheduleTomorrow(ActionOrder.PRODUCTION,this);
        }
    });
}
 

import sim.engine.Steppable; //导入依赖的package包/类
private void createBuyer(final EconomicAgent seller, Market market, int price, float time){

        /**
         * For this scenario we use dummy buyers that shop only once every "period"
         */
        final DummyBuyer buyer = new DummyBuyer(getModel(),price,market);  market.registerBuyer(buyer);
        buyer.receiveMany(UndifferentiatedGoodType.MONEY,1000000);

        //Make it shop once a day for one good only!
        getModel().scheduleSoon(ActionOrder.TRADE,
                new Steppable() {
                    @Override
                    public void step(SimState simState) {


                        DummyBuyer.goShopping(buyer,seller, UndifferentiatedGoodType.GENERIC);
                        getModel().scheduleTomorrow(ActionOrder.TRADE,this);
                    }
                }
        );


        getAgents().add(buyer);
    }
 

import sim.engine.Steppable; //导入依赖的package包/类
public Firm buildFirm() {
    //only one seller
    final Firm built= new Firm(getModel());
    built.receiveMany(UndifferentiatedGoodType.MONEY,500000000);
    // built.setName("monopolist");
    //set up the firm at time 1
    getModel().scheduleSoon(ActionOrder.DAWN, new Steppable() {
        @Override
        public void step(SimState simState) {
            buildSalesDepartmentToFirm(built);
            Plant plant = buildPlantForFirm(built);
            buildHrForFirm(plant, built);


        }
    });

    model.addAgent(built);
    return built;
}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 /**
 * The adjust is the main part of the a controller. It checks the new error and set the MV (which is the price, really)
 *
 * @param stockTarget the stock target
 * @param stockInput the stock input
 * @param flowInput the flow input
 * @param isActive true if the pid is not turned off
 * @param state   the simstate link to schedule the user
 * @param user     the user who calls the PID (it needs to be steppable since the PID doesn't adjust itself)
 */
public void adjust(float stockTarget,float stockInput, float flowInput, boolean isActive,
                    MacroII state,  Steppable user,  ActionOrder phase)
{
    //master
    pid1.adjust(stockTarget,stockInput,isActive,state,user,phase); //to avoid exxaggerating in disinvesting, the recorded inventory is never more than twice the target
    //slave

    targetForSlavePID = pid1.getCurrentMV();
    // targetForSlavePID = masterOutput > 1 ? (float)Math.log(masterOutput) : masterOutput < -1 ? -(float)Math.log(-masterOutput) : 0;
    //

    assert !Float.isNaN(targetForSlavePID) && !Float.isInfinite(targetForSlavePID);
    ControllerInput secondPIDInput = new ControllerInput(targetForSlavePID,flowInput);
    pid2.adjust(secondPIDInput, isActive, null, null, null);


}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 * The adjust is the main part of the PID Controller. This method doesn't compute but rather receive the new error
 * and just perform the PID magic on it
 * @param residual the residual/error: the difference between current value of y and its target
 * @param isActive is the agent calling this still alive and active?
 * @param simState a link to the model (to reschedule the user)
 * @param user     the user who calls the PID (it needs to be steppable since the PID doesn't adjust itself)
 * @param phase at which phase should this controller be rescheduled
 */
public void adjust(float residual, boolean isActive,
                   MacroII simState,  Steppable user,ActionOrder phase, Priority priority)
{
    //delegate the PID itself to adjustOnce, and worry about refactoring
    if (!adjustOnce(residual, isActive))
        return;


    /*************************
     * Reschedule
     *************************/


    if(simState != null && user != null){
        if(speed == 0)
            simState.scheduleTomorrow(phase, user,priority);
        else
        {
            assert speed > 0;
            simState.scheduleAnotherDay(phase,user,speed+1,priority);
        }
    }

}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 /**
 * The adjust is the main part of the a controller. It checks the new error and set the MV (which is the price, really)
 *
 * @param stockTarget the stock target
 * @param stockInput the stock input
 * @param flowInput the flow input
 * @param isActive true if the pid is not turned off
 * @param state   the simstate link to schedule the user
 * @param user     the user who calls the PID (it needs to be steppable since the PID doesn't adjust itself)     * @param firstTarget
 */
public void adjust(float stockTarget,float stockInput, float flowInput, boolean isActive,
                   MacroII state,  Steppable user,  ActionOrder phase)
{
    //master
    pid1.adjust(stockTarget,Math.min(stockInput,stockTarget*5),isActive,state,user,phase); //to avoid exxaggerating in disinvesting, the recorded inventory is never more than twice the target
    //slave

    targetForSlavePID = pid1.getCurrentMV();
    // targetForSlavePID = masterOutput > 1 ? (float)Math.log(masterOutput) : masterOutput < -1 ? -(float)Math.log(-masterOutput) : 0;
    //

    assert !Float.isNaN(targetForSlavePID) && !Float.isInfinite(targetForSlavePID);
    ControllerInput secondPIDInput = new ControllerInput(targetForSlavePID,flowInput);
    pid2.adjust(secondPIDInput, isActive, null, null, null);


}
 

import sim.engine.Steppable; //导入依赖的package包/类
@Test
public void createPeriodicNE() {
    Steppable generator = new Steppable() {

        private static final long serialVersionUID = 1L;

        public void step(SimState arg0) {

        }
    };
    PeriodicNetworkElementEvent pe = new MyPeriodicNetElementEvent(
            generator);

    Assert.assertEquals(generator, pe.getLauncher());
    Assert.assertEquals(500, pe.getPeriod());

}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 * The adjust is the main part of the a controller. It checks the new error and set the MV (which is the price, really)
 *
 * @param input the input object
 * @param isActive are we active?
 * @param simState a link to the model (to adjust yourself)
 * @param user     the user who calls the PID (it needs to be steppable since the PID doesn't adjust itself)
 */
@Override
public void adjust(ControllerInput input,  boolean isActive, MacroII simState, Steppable user,ActionOrder phase) {
    if(position.equals(ControllerInput.Position.FLOW)) {
        filter.addObservation(input.getFlowTarget());
        input = new ControllerInput(filter.getSmoothedObservation(),input.getStockTarget(),input.getFlowInput(),input.getStockInput() );
    }
    else{
        assert position.equals(ControllerInput.Position.STOCK);
        filter.addObservation(input.getStockTarget());
        input = new ControllerInput(input.getFlowTarget(),filter.getSmoothedObservation(),input.getFlowInput(), input.getStockInput());

    }



    toDecorate.adjust(input,isActive,simState,user,phase);


}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 * The adjust is the main part of the a controller. It checks the new error and set the MV (which is the price, really)
 *
 * @param input the controller input object
 * @param isActive are we active?
 * @param simState a link to the model (to adjust yourself)
 * @param user     the user who calls the PID (it needs to be steppable since the PID doesn't adjust itself)
 */
@Override
public void adjust(ControllerInput input, boolean isActive, MacroII simState, Steppable user, ActionOrder phase) {

    if(position.equals(ControllerInput.Position.FLOW)) {
        filter.addObservation(input.getFlowInput());
        input = new ControllerInput(input.getFlowTarget(),input.getStockTarget(),filter.getSmoothedObservation(),input.getStockInput());
    }
    else{
        assert position.equals(ControllerInput.Position.STOCK);
        filter.addObservation(input.getStockInput());
        input = new ControllerInput(input.getFlowTarget(),input.getStockTarget(),input.getStockTarget(),filter.getSmoothedObservation());

    }
    toDecorate.adjust(input,isActive,simState,user, phase);


}
 

import sim.engine.Steppable; //导入依赖的package包/类
@Test
public void createActionAndNoExecuteAction() throws ShanksException{
    @SuppressWarnings("serial")
    Steppable launcher = new Steppable() {
        @Override
        public void step(SimState arg0) {
        }
    };
    Action act = new MyShanksAgentAction("Action", launcher);
    
    Assert.assertEquals("Action", act.getID());
    Assert.assertEquals(launcher, act.getLauncher());
    
    Device d = new MyDevice("Dev", MyDevice.NOK_STATUS, false, logger);
    Assert.assertEquals("Dev", d.getID());
    Assert.assertTrue(d.getStatus().get(MyDevice.NOK_STATUS));
    Assert.assertFalse(d.isGateway());
    
    
    
}
 

import sim.engine.Steppable; //导入依赖的package包/类
public void attachFilter(final Filter<Integer> outflowFilter)
{

    //set it
    this.outflowFilter = outflowFilter;
    outflowFilter.addObservation(department.getTodayOutflow());
    //schedule it
    department.getFirm().getModel().scheduleSoon(ActionOrder.THINK,new Steppable() {
        @Override
        public void step(SimState state) {
            if(InventoryBufferSalesControl.this.outflowFilter != outflowFilter) //stop if you changed filter
                return;

            //add observation
            outflowFilter.addObservation(department.getTodayOutflow());

            //reschedule yourself
            department.getFirm().getModel().scheduleTomorrow(ActionOrder.THINK,this);


        }
    }

    );

}
 

import sim.engine.Steppable; //导入依赖的package包/类
/**
 * Start the inventory control and make the purchaseDepartment, if needed, buy stuff
 */
public void start(MacroII model){
    Preconditions.checkArgument(!startWasCalled);
    startWasCalled = true;

    counter.start();
    control.start();
    purchasesData.start(model,this);

    model.scheduleSoon(ActionOrder.ADJUST_PRICES,new Steppable() {
        @Override
        public void step(SimState state) {
            if(!(isActive()))
                return;

            priceAverager.endOfTheDay(PurchasesDepartment.this);
            model.scheduleTomorrow(ActionOrder.ADJUST_PRICES,this);

        }
    });

}