Esempio n. 1
0
    public DumpWrapper Dump()
    {
        var ret = new DumpWrapper();

        ret.name           = Name;
        ret.minimalPLMDump = minimalPlayablePLM;
        ret.canvasDump     = CanvasConfig.StaticSerialize(canvasConfig);
        ret.matchRuleDumps = matchRules.SchemeStyleMap <RuleMatchBasic, string>((r) => {
            return(RuleMatchBasic.StaticSerialize(r));
        });
        ret.operationRuleDumps = operationRules.SchemeStyleMap <RuleOperation, string>((r) => {
            return(RuleOperation.StaticSerialize(r));
        });
        ret.extensionRuleDumps = extensionRules.SchemeStyleMap <RuleMatchExtension, string>((r) => {
            return(RuleMatchExtension.StaticSerialize(r));
        });
        ret.scoreRuleDumps = scoreRules.SchemeStyleMap <RuleScore, string>((r) => {
            return(RuleScore.StaticSerialize(r));
        });
        ret.refillRuleDump = RuleRefill.StaticSerialize(refillRule);
        ret.traitDumps     = slotConfig.Traits.SchemeStyleMap <SlotTrait, string>((t) => {
            return(SlotTrait.StaticSerialize(t));
        });
        ret.specialDumps = new List <string>();
        foreach (var kvp in slotConfig.Specials)
        {
            ret.specialDumps.Add(SlotSpecialty.StaticSerialize(kvp.Value));
        }
        return(ret);
    }
Esempio n. 2
0
    private static bool CheckMatchRule(RuleMatchBasic rule, out string reason)
    {
        reason = "";
        var r1 = rule as RuleMatchBasic2D_Rectangular;

        if (null != r1)
        {
            int count = 0;
            foreach (var b in r1.mask)
            {
                if (b)
                {
                    count++;
                }
            }
            if (count <= 2)
            {
                reason = "Illegal Match Rule!";
                return(false);
            }

            return(true);
        }
        throw new NotImplementedException();
    }
Esempio n. 3
0
 private void InitFrom(DumpWrapper dump)
 {
     Name = dump.name;
     minimalPlayablePLM = dump.minimalPLMDump;
     canvasConfig       = CanvasConfig.StaticDeserialize(dump.canvasDump);
     slotConfig         = new SlotConfig();
     slotConfig.Init(dump.traitDumps, dump.specialDumps);
     matchRules = dump.matchRuleDumps.SchemeStyleMap <string, RuleMatchBasic>((str) => {
         return(RuleMatchBasic.StaticDeserialize(str));
     });
     operationRules = dump.operationRuleDumps.SchemeStyleMap <string, RuleOperation>((str) => {
         return(RuleOperation.StaticDeserialize(str));
     });
     extensionRules = dump.extensionRuleDumps.SchemeStyleMap <string, RuleMatchExtension>((str) => {
         return(RuleMatchExtension.StaticDeserialize(str));
     });
     scoreRules = dump.scoreRuleDumps.SchemeStyleMap <string, RuleScore>((str) => {
         return(RuleScore.StaticDeserialize(str));
     });
     refillRule = RuleRefill.StaticDeserialize(dump.refillRuleDump);
 }
Esempio n. 4
0
	private static bool CheckMatchRule(RuleMatchBasic rule, out string reason)
	{
		reason = "";
		var r1 = rule as RuleMatchBasic2D_Rectangular;
		if (null != r1)
		{
			int count = 0;
			foreach (var b in r1.mask)
			{
				if (b) count++;
			}
			if (count <= 2)
			{
				reason = "Illegal Match Rule!";
				return false;
			}

			return true;
		}
		throw new NotImplementedException();
	}
Esempio n. 5
0
	public static string StaticSerialize(RuleMatchBasic r)
	{
		return JsonHelper.Serialize(new Tuple<string, string>(r.SerializeUID, r.Serialize()));
	}
Esempio n. 6
0
 public static string StaticSerialize(RuleMatchBasic r)
 {
     return(JsonHelper.Serialize(new Tuple <string, string>(r.SerializeUID, r.Serialize())));
 }