public static GameRuleMetaRule unpackFromString(GameRuleDeserializer deserializer)
{
byte subclassByte = deserializer.unpackByte(GAME_RULE_META_RULE_BIT_SIZE);
if (subclassByte == GAME_RULE_PLAYER_SWAP_META_RULE_BYTE_VAL)
return GameRulePlayerSwapMetaRule.unpackFromString(deserializer);
else
throw new System.Exception("Invalid GameRuleMetaRule unpacked byte " + subclassByte);
}
public static GameRuleAction unpackFromString(GameRuleDeserializer deserializer)
{
byte subclassByte = deserializer.unpackByte(GAME_RULE_ACTION_BIT_SIZE);
if (subclassByte == GAME_RULE_EFFECT_ACTION_BYTE_VAL)
return GameRuleEffectAction.unpackFromString(deserializer);
else if (subclassByte == GAME_RULE_META_RULE_ACTION_BYTE_VAL)
return GameRuleMetaRuleAction.unpackFromString(deserializer);
else
throw new System.Exception("Invalid GameRuleAction unpacked byte " + subclassByte);
}
public static GameRuleActionDuration unpackFromString(GameRuleDeserializer deserializer)
{
byte subclassByte = deserializer.unpackByte(GAME_RULE_ACTION_DURATION_BIT_SIZE);
if (subclassByte == 0)
return GameRuleActionFixedDuration.unpackFromString(deserializer);
else if (subclassByte == 1)
return GameRuleActionUntilConditionDuration.unpackFromString(deserializer);
else
throw new System.Exception("Invalid GameRuleActionDuration unpacked byte " + subclassByte);
}
public static new GameRulePlayerSwapMetaRule unpackFromString(GameRuleDeserializer deserializer)
{
return new GameRulePlayerSwapMetaRule();
}
public static new GameRuleMetaRuleAction unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleMetaRule imr = GameRuleMetaRule.unpackFromString(deserializer);
return new GameRuleMetaRuleAction(imr);
}
public static GameRule unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleCondition condition = GameRuleCondition.unpackFromString(deserializer);
GameRuleAction action = GameRuleAction.unpackFromString(deserializer);
return new GameRule(condition, action);
}
public static new GameRuleSourceSelector unpackFromString(GameRuleDeserializer deserializer)
{
byte subclassByte = deserializer.unpackByte(GAME_RULE_SOURCE_SELECTOR_BIT_SIZE);
if (subclassByte == GAME_RULE_PLAYER_SOURCE_SELECTOR_BYTE_VAL)
return GameRulePlayerSelector.instance;
else if (subclassByte == GAME_RULE_BALL_SOURCE_SELECTOR_BYTE_VAL)
return GameRuleBallSelector.instance;
else
throw new System.Exception("Invalid GameRuleSelector unpacked byte " + subclassByte);
}
public static new GameRuleActionFixedDuration unpackFromString(GameRuleDeserializer deserializer)
{
//we only store non-negative values
int d = deserializer.unpackByte(DURATION_SERIALIZATION_BIT_COUNT);
return new GameRuleActionFixedDuration(d);
}
public static new GameRuleZoneCondition unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleRequiredObject zt = deserializer.unpackFromString(Zone.standardZoneTypes);
GameRuleSourceSelector s = GameRuleSourceSelector.unpackFromString(deserializer);
return new GameRuleZoneCondition(zt, s);
}
public static new GameRuleFreezeEffect unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleActionDuration d = GameRuleActionDuration.unpackFromString(deserializer);
return new GameRuleFreezeEffect(d);
}
public static new GameRuleEffectAction unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleSelector s = GameRuleSelector.unpackFromString(deserializer);
GameRuleEffect ia = GameRuleEffect.unpackFromString(deserializer);
return new GameRuleEffectAction(s, ia);
}
public static GameRuleEffect unpackFromString(GameRuleDeserializer deserializer)
{
byte subclassByte = deserializer.unpackByte(GAME_RULE_EFFECT_BIT_SIZE);
if (subclassByte == GAME_RULE_POINTS_PLAYER_EFFECT_BYTE_VAL)
return GameRulePointsPlayerEffect.unpackFromString(deserializer);
else if (subclassByte == GAME_RULE_DUPLICATE_EFFECT_BYTE_VAL)
return GameRuleDuplicateEffect.unpackFromString(deserializer);
else if (subclassByte == GAME_RULE_FREEZE_EFFECT_BYTE_VAL)
return GameRuleFreezeEffect.unpackFromString(deserializer);
else if (subclassByte == GAME_RULE_DIZZY_EFFECT_BYTE_VAL)
return GameRuleDizzyEffect.unpackFromString(deserializer);
else if (subclassByte == GAME_RULE_BOUNCE_EFFECT_BYTE_VAL)
return GameRuleBounceEffect.unpackFromString(deserializer);
else
throw new System.Exception("Invalid GameRuleEffect unpacked byte " + subclassByte);
}
public static new GameRuleDuplicateEffect unpackFromString(GameRuleDeserializer deserializer)
{
return new GameRuleDuplicateEffect();
}
public static new GameRuleActionUntilConditionDuration unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleEventHappenedCondition uc = GameRuleEventHappenedCondition.unpackFromString(deserializer);
return new GameRuleActionUntilConditionDuration(uc);
}
public static GameRuleCondition unpackFromString(GameRuleDeserializer deserializer)
{
byte subclassByte = deserializer.unpackByte(GAME_RULE_CONDITION_BIT_SIZE);
if (subclassByte == GAME_RULE_COMPARISON_CONDITION_BYTE_VAL)
return GameRuleComparisonCondition.unpackFromString(deserializer);
else if (subclassByte == GAME_RULE_EVENT_HAPPENED_CONDITION_BYTE_VAL)
return GameRuleEventHappenedCondition.unpackFromString(deserializer);
else if (subclassByte == GAME_RULE_ZONE_CONDITION_BYTE_VAL)
return GameRuleZoneCondition.unpackFromString(deserializer);
else
throw new System.Exception("Invalid GameRuleCondition unpacked byte " + subclassByte);
}
/*
public GameRuleConditionOperator conditionOperator;
public GameRuleComparisonCondition(GameRuleConditionOperator grco) {
conditionOperator = grco;
}
public override void addIcons(List<Sprite> iconList) {
throw new System.Exception("Icon displays not yet supported for comparison conditions!");
}
public override void packToString(GameRuleSerializer serializer) {
serializer.packByte(GAME_RULE_CONDITION_BIT_SIZE, GAME_RULE_COMPARISON_CONDITION_BYTE_VAL);
throw new System.Exception("Rule serialization not yet supported for comparison conditions!");
}
*/
public static new GameRuleComparisonCondition unpackFromString(GameRuleDeserializer deserializer)
{
throw new System.Exception("Rule deserialization not yet supported for comparison conditions!");
}
public static new GameRulePointsPlayerEffect unpackFromString(GameRuleDeserializer deserializer)
{
//if it's over the max value, it's actually the low bits of a negative number
int pg = deserializer.unpackByte(POINTS_SERIALIZATION_BIT_COUNT);
if (pg > POINTS_SERIALIZATION_MAX_VALUE)
pg |= ~POINTS_SERIALIZATION_MASK;
return new GameRulePointsPlayerEffect(pg);
}
public static new GameRuleEventHappenedCondition unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleEventType et = deserializer.unpackFromString(GameRuleEvent.eventTypesList);
System.Type st = deserializer.unpackFromString(GameRuleEvent.eventTypeSourcesList[et]);
System.Type tt = deserializer.unpackFromString(GameRuleEvent.potentialEventsList[et][st]);
string p = (tt == typeof(FieldObject)) ? deserializer.unpackFromString(FieldObject.standardFieldObjects) : null;
return new GameRuleEventHappenedCondition(et, st, tt, p);
}
public static new GameRuleActionUntilConditionDuration unpackFromString(GameRuleDeserializer deserializer)
{
GameRuleSelector ts = GameRuleSelector.unpackFromString(deserializer);
//we know that it's an event-happened condition so we load it directly as that
GameRuleEventHappenedCondition uc = GameRuleEventHappenedCondition.unpackFromString(deserializer);
return new GameRuleActionUntilConditionDuration(ts, uc);
}
