Esempio n. 1
0
    public static bool CheckScheme(PlayableScheme scheme, out string reason)
    {
        reason = "";
        if (String.IsNullOrEmpty(scheme.Name))
        {
            reason = "Invalid Scheme Name!";
            return(false);
        }
        if (null == scheme.canvasConfig)
        {
            reason = "No Canvas Config";
            return(false);
        }
        if (!CheckCanvas(scheme.canvasConfig, out reason))
        {
            return(false);
        }
        if (null == scheme.slotConfig || null == scheme.slotConfig.Traits || scheme.slotConfig.Traits.Count <= 1)
        {
            reason = "Illegal slot trait config!";
            return(false);
        }
        if (null == scheme.matchRules || scheme.matchRules.Count <= 0)
        {
            reason = "No Match Rule Found!";
            return(false);
        }
        foreach (var r in scheme.matchRules)
        {
            if (!CheckMatchRule(r, out reason))
            {
                return(false);
            }
        }
        if (null == scheme.operationRules || scheme.operationRules.Count <= 0)
        {
            reason = "No Operation Rule Found!";
            return(false);
        }
        foreach (var r in scheme.operationRules)
        {
            if (!CheckOperationRule(r, out reason))
            {
                return(false);
            }
        }
        if (!DryRun(scheme, out reason))
        {
            return(false);
        }

        return(true);
    }
Esempio n. 2
0
    private static PlayableScheme CreateEmptyScheme2DR()
    {
        var ret = new PlayableScheme();

        ret.Name = "";

        ret.canvasConfig = new CanvasConfig2DR();
        var c = ret.canvasConfig as CanvasConfig2DR;

        c.mapWidth   = 10;
        c.mapHeight  = 10;
        c.insulators = new List <Pos2D>();

        ret.slotConfig = new SlotConfig();
        ret.slotConfig.Init(new List <string>(), new List <string>());

        ret.matchRules     = new List <RuleMatchBasic>();
        ret.extensionRules = new List <RuleMatchExtension>();
        ret.operationRules = new List <RuleOperation>();
        ret.refillRule     = new RuleRefill2DR_Downward();
        ret.scoreRules     = new List <RuleScore>();
        return(ret);
    }
Esempio n. 3
0
    public PlayableEnv2DR Build_2DR(PlayableScheme scheme)
    {
        var env = new PlayableEnv2DR();

        env.MinimalPlayablePLM = scheme.minimalPlayablePLM;
        env.Foreground         = new Container2D_Rectangular(scheme.canvasConfig as CanvasConfig2DR,
                                                             scheme.slotConfig);
        env.Background = new Container2D_Rectangular(scheme.canvasConfig as CanvasConfig2DR,
                                                     scheme.slotConfig);

        env.MatchRules = scheme.matchRules.SchemeStyleMap <RuleMatchBasic, RuleMatchBasic2D_Rectangular>((r) => {
            var raw        = r as RuleMatchBasic2D_Rectangular;
            var ret        = new RuleMatchBasic2D_Rectangular();
            ret.maskWidth  = raw.maskWidth;
            ret.maskHeight = raw.maskHeight;
            ret.mask       = raw.mask;
            ret.Compile();
            return(ret);
        }).ToArray();

        env.ExtensionRules = scheme.extensionRules.SchemeStyleMap <RuleMatchExtension, RuleMatchExtension2D_Rectangular>((r) => {
            return(r as RuleMatchExtension2D_Rectangular);
        }).ToArray();

        env.RefillRule = scheme.refillRule as RuleRefill2D_Rectangular;

        env.OperationRules = scheme.operationRules.SchemeStyleMap <RuleOperation, RuleOperation2D_Rectangular>((r) => {
            return(r as RuleOperation2D_Rectangular);
        }).ToArray();

        env.ScoreRules = scheme.scoreRules.SchemeStyleMap <RuleScore, RuleScore2D_Rectangular>((r) => {
            return(r as RuleScore2D_Rectangular);
        }).ToArray();

        return(env);
    }
Esempio n. 4
0
    private static bool DryRun(PlayableScheme scheme, out string reason)
    {
        reason = "";
        if (scheme.canvasConfig is CanvasConfig2DR)
        {
            var container = new Container2D_Rectangular(scheme.canvasConfig as CanvasConfig2DR,
                                                        scheme.slotConfig);
            container.InitBlocks();

            var count1 = 0;
            var count2 = 0;
            for (int i = 0; i < 20; i++)
            {
                container.RecreateSubjects(true);
                var ctx1 = new LMSeeker2D_Retangular.SeekContext();
                ctx1.container  = container;
                ctx1.matchRules = scheme.matchRules.SchemeStyleMap <RuleMatchBasic, RuleMatchBasic2D_Rectangular>((r) => {
                    var raw        = r as RuleMatchBasic2D_Rectangular;
                    var ret        = new RuleMatchBasic2D_Rectangular();
                    ret.mask       = raw.mask;
                    ret.maskWidth  = raw.maskWidth;
                    ret.maskHeight = raw.maskHeight;
                    ret.Compile();
                    return(ret);
                }).ToArray();
                ctx1.result = new List <LMRecord2D_Retangular>();
                LMSeeker2D_Retangular.Seek(ctx1);
                if (ctx1.result.Count > 0)
                {
                    count1++;
                }

                var ctx2 = new PLMSeeker2D_Retangular.SeekContext();
                ctx2.container  = container;
                ctx2.matchRules = scheme.matchRules.SchemeStyleMap <RuleMatchBasic, RuleMatchBasic2D_Rectangular>((r) => {
                    var raw        = r as RuleMatchBasic2D_Rectangular;
                    var ret        = new RuleMatchBasic2D_Rectangular();
                    ret.mask       = raw.mask;
                    ret.maskWidth  = raw.maskWidth;
                    ret.maskHeight = raw.maskHeight;
                    ret.Compile();
                    return(ret);
                }).ToArray();
                ctx2.operationRules = scheme.operationRules.SchemeStyleMap <RuleOperation, RuleOperation2D_Rectangular>((r) => {
                    return(r as RuleOperation2D_Rectangular);
                }).ToArray();
                ctx2.result = new List <PLMRecord2D_Retangular>();
                PLMSeeker2D_Retangular.Seek(ctx2);
                if (ctx2.result.Count >= scheme.minimalPlayablePLM)
                {
                    count2++;
                }
            }

            if (count1 < 2 || count2 < 2)
            {
                reason = "Scheme is NOT playable!";
                return(false);
            }

            return(true);
        }
        throw new NotImplementedException();
    }
Esempio n. 5
0
	private static bool DryRun(PlayableScheme scheme, out string reason)
	{
		reason = "";
		if (scheme.canvasConfig is CanvasConfig2DR)
		{
			var container = new Container2D_Rectangular(scheme.canvasConfig as CanvasConfig2DR,
			                                            scheme.slotConfig);
			container.InitBlocks();

			var count1 = 0;
			var count2 = 0;
			for (int i = 0; i < 20; i++)
			{
				container.RecreateSubjects(true);
				var ctx1 = new LMSeeker2D_Retangular.SeekContext();
				ctx1.container = container;
				ctx1.matchRules = scheme.matchRules.SchemeStyleMap<RuleMatchBasic, RuleMatchBasic2D_Rectangular>((r)=>{
					var raw = r as RuleMatchBasic2D_Rectangular;
					var ret = new RuleMatchBasic2D_Rectangular();
					ret.mask = raw.mask;
					ret.maskWidth = raw.maskWidth;
					ret.maskHeight = raw.maskHeight;
					ret.Compile();
					return ret;
				}).ToArray();
				ctx1.result = new List<LMRecord2D_Retangular>();
				LMSeeker2D_Retangular.Seek(ctx1);
				if (ctx1.result.Count > 0)
				{
					count1++;
				}

				var ctx2 = new PLMSeeker2D_Retangular.SeekContext();
				ctx2.container = container;
				ctx2.matchRules = scheme.matchRules.SchemeStyleMap<RuleMatchBasic, RuleMatchBasic2D_Rectangular>((r)=>{
					var raw = r as RuleMatchBasic2D_Rectangular;
					var ret = new RuleMatchBasic2D_Rectangular();
					ret.mask = raw.mask;
					ret.maskWidth = raw.maskWidth;
					ret.maskHeight = raw.maskHeight;
					ret.Compile();
					return ret;
				}).ToArray();
				ctx2.operationRules = scheme.operationRules.SchemeStyleMap<RuleOperation, RuleOperation2D_Rectangular>((r)=>{
					return r as RuleOperation2D_Rectangular;
				}).ToArray();
				ctx2.result = new List<PLMRecord2D_Retangular>();
				PLMSeeker2D_Retangular.Seek(ctx2);
				if (ctx2.result.Count >= scheme.minimalPlayablePLM)
				{
					count2++;
				}
			}

			if (count1 < 2 || count2 < 2)
			{
				reason = "Scheme is NOT playable!";
				return false;
			}

			return true;
		}
		throw new NotImplementedException();
	}
Esempio n. 6
0
	public static bool CheckScheme(PlayableScheme scheme, out string reason)
	{
		reason = "";
		if (String.IsNullOrEmpty(scheme.Name))
		{
			reason = "Invalid Scheme Name!";
			return false;
		}
		if (null == scheme.canvasConfig)
		{
			reason = "No Canvas Config";
			return false;
		}
		if (!CheckCanvas(scheme.canvasConfig, out reason))
		{
			return false;
		}
		if (null == scheme.slotConfig || null == scheme.slotConfig.Traits || scheme.slotConfig.Traits.Count <= 1)
		{
			reason = "Illegal slot trait config!";
			return false;
		}
		if (null == scheme.matchRules || scheme.matchRules.Count <= 0)
		{
			reason = "No Match Rule Found!";
			return false;
		}
		foreach (var r in scheme.matchRules)
		{
			if (!CheckMatchRule(r, out reason))
			{
				return false;
			}
		}
		if (null == scheme.operationRules || scheme.operationRules.Count <= 0)
		{
			reason = "No Operation Rule Found!";
			return false;
		}
		foreach (var r in scheme.operationRules)
		{
			if (!CheckOperationRule(r, out reason))
			{
				return false;
			}
		}
		if (!DryRun(scheme, out reason))
		{
			return false;
		}

		return true;
	}