public void Update()
{
//our instance can't do anything until the other instances are ready
if (!finishedInstantiating && GameRuleIconStorage.instance != null && GameRuleSpawnableObjectRegistry.instance != null) {
//add descriptors for selectable components to the selection map
//classes with subcomponents will also produce popups
//conditions
List<GameRuleDesignComponentDescriptor> gameRuleConditionSelection = (componentSelectionMap[typeof(GameRuleCondition)] = new List<GameRuleDesignComponentDescriptor>());
gameRuleEventHappenedConditionDurationDescriptor = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleEventHappenedCondition),
GameRuleIconStorage.instance.genericEventIcon, 0,
new System.Type[] {
typeof(GameRuleEventType)
});
gameRuleConditionSelection.Add(gameRuleEventHappenedConditionDurationDescriptor);
gameRuleConditionSelection.Add(new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleZoneCondition),
GameRuleIconStorage.instance.genericZoneIcon, 1,
new System.Type[] {
typeof(GameRuleSourceSelector),
typeof(RuleStubZoneType)
}));
//actions get specially handled since their class is controlled by the condition
//they don't have icons because they never appear in popups and are fully represented by the icons in their subcomponents
//the subcomponents will get assigned in complementComponent
gameRuleEffectActionDescriptor = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleEffectAction),
null, -1,
null);
//metarules don't even have any popup, they are 100% 1:1 with conditions
gameRuleMetaRuleActionDescriptor = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleMetaRuleAction),
null, -1,
null);
//event types for GameRuleEventHappenedConditions
List<GameRuleDesignComponentDescriptor> gameRuleEventTypeSelection = (componentSelectionMap[typeof(GameRuleEventType)] = new List<GameRuleDesignComponentDescriptor>());
foreach (GameRuleEventType eventType in GameRuleEvent.eventTypesList) {
gameRuleEventTypeSelection.Add(new GameRuleDesignComponentEventTypeDescriptor(eventType, 1));
}
//selectors
//these get used for a few things
//selectors and effects for actions change based on the event type source
List<GameRuleDesignComponentDescriptor> playerSelectorSelection = (sourceSelectorMap[typeof(TeamPlayer)] = new List<GameRuleDesignComponentDescriptor>());
foreach (GameRuleSelector selector in GameRuleSelector.getPlayerSourceSelectors()) {
playerSelectorSelection.Add(new GameRuleDesignComponentSelectorDescriptor(selector));
}
List<GameRuleDesignComponentDescriptor> ballSelectorSelection = (sourceSelectorMap[typeof(Ball)] = new List<GameRuleDesignComponentDescriptor>());
foreach (GameRuleSelector selector in GameRuleSelector.getBallSourceSelectors()) {
ballSelectorSelection.Add(new GameRuleDesignComponentSelectorDescriptor(selector));
}
//zone types
//each zone type corresponds to one metarule
List<GameRuleDesignComponentDescriptor> zoneSelection = (componentSelectionMap[typeof(RuleStubZoneType)] = new List<GameRuleDesignComponentDescriptor>());
zoneSelection.Add(new GameRuleDesignComponentZoneTypeDescriptor(
GameRuleRequiredObjectType.BoomerangZone,
GameRuleIconStorage.instance.boomerangZoneIcon));
//right now this is only for zones which are only on players
List<GameRuleDesignComponentDescriptor> gameRuleSourceSelectorSelection = (componentSelectionMap[typeof(GameRuleSourceSelector)] = new List<GameRuleDesignComponentDescriptor>());
gameRuleSourceSelectorSelection.Add(new GameRuleDesignComponentSelectorDescriptor(GameRulePlayerSelector.instance));
//effects
//first, map each effect to a descriptor
Dictionary<System.Type, GameRuleDesignComponentDescriptor> effectTypeDescriptorMap = new Dictionary<System.Type, GameRuleDesignComponentDescriptor>();
effectTypeDescriptorMap[typeof(GameRulePointsPlayerEffect)] = new GameRuleDesignComponentClassDescriptor(
typeof(GameRulePointsPlayerEffect),
//this descriptor doesn't have an icon but components for it will make one
null, 0,
new System.Type[] {
//we'll just use this as the key for our list of possible point values
typeof(GameRulePointsPlayerEffect)
});
effectTypeDescriptorMap[typeof(GameRuleDuplicateEffect)] = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleDuplicateEffect),
GameRuleIconStorage.instance.duplicatedIcon, 0, null);
effectTypeDescriptorMap[typeof(GameRuleFreezeEffect)] = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleFreezeEffect),
GameRuleIconStorage.instance.frozenIcon, 0,
new System.Type[] {
typeof(GameRuleActionDuration)
});
effectTypeDescriptorMap[typeof(GameRuleDizzyEffect)] = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleDizzyEffect),
GameRuleIconStorage.instance.dizzyIcon, 0,
new System.Type[] {
typeof(GameRuleActionDuration)
});
effectTypeDescriptorMap[typeof(GameRuleBounceEffect)] = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleBounceEffect),
GameRuleIconStorage.instance.bouncyIcon, 0,
new System.Type[] {
typeof(GameRuleActionDuration)
});
//next, go through and pull all the effect types from their corresponding list
List<GameRuleDesignComponentDescriptor> playerEffectSelection = (sourceEffectMap[typeof(TeamPlayer)] = new List<GameRuleDesignComponentDescriptor>());
foreach (System.Type effectType in GameRuleEffect.playerSourceEffects) {
playerEffectSelection.Add(effectTypeDescriptorMap[effectType]);
}
List<GameRuleDesignComponentDescriptor> ballEffectSelection = (sourceEffectMap[typeof(Ball)] = new List<GameRuleDesignComponentDescriptor>());
foreach (System.Type effectType in GameRuleEffect.ballSourceEffects) {
ballEffectSelection.Add(effectTypeDescriptorMap[effectType]);
}
//metarules are controlled by the zones
zoneTypeMetaRuleMap[GameRuleRequiredObjectType.BoomerangZone] = new GameRuleDesignComponentMetaRuleDescriptor(
GameRulePlayerSwapMetaRule.instance);
//event sources and targets
GameRuleDesignComponentEventParticipantDescriptor teamPlayerDescriptor = new GameRuleDesignComponentEventParticipantDescriptor(
typeof(TeamPlayer),
GameRuleIconStorage.instance.playerIcon);
GameRuleDesignComponentEventParticipantDescriptor ballDescriptor = new GameRuleDesignComponentEventParticipantDescriptor(
typeof(Ball),
GameRuleIconStorage.instance.genericBallIcon);
List<GameRuleDesignComponentDescriptor> fieldObjectDescriptors = new List<GameRuleDesignComponentDescriptor>();
foreach (GameRuleSpawnableObject spawnableObject in GameRuleSpawnableObjectRegistry.instance.goalSpawnableObjects) {
fieldObjectDescriptors.Add(new GameRuleDesignComponentFieldObjectDescriptor(
spawnableObject.spawnedObject.GetComponent<FieldObject>().sportName,
spawnableObject.icon));
}
fieldObjectDescriptors.Add(new GameRuleDesignComponentFieldObjectDescriptor(
"boundary",
GameRuleIconStorage.instance.boundaryIcon));
//go through all the event types and build up the lists of the potential source and target descriptors per event type
foreach (GameRuleEventType eventType in GameRuleEvent.eventTypesList) {
List<GameRuleDesignComponentDescriptor> sourcesList = (potentialSourcesForEventMap[eventType] = new List<GameRuleDesignComponentDescriptor>());
Dictionary<System.Type, List<GameRuleDesignComponentDescriptor>> targetsMap =
(potentialTargetsForEventSourceMap[eventType] = new Dictionary<System.Type, List<GameRuleDesignComponentDescriptor>>());
foreach (KeyValuePair<System.Type, List<System.Type>> sourceAndTargets in GameRuleEvent.potentialEventsList[eventType]) {
//add this source to the list of sources for the event type
System.Type sourceType = sourceAndTargets.Key;
if (sourceType == typeof(TeamPlayer))
sourcesList.Add(teamPlayerDescriptor);
else if (sourceType == typeof(Ball))
sourcesList.Add(ballDescriptor);
else
throw new System.Exception("Bug: invalid event source type " + sourceType);
//add all the targets to this source's list of targets for this event type
List<GameRuleDesignComponentDescriptor> targetsList = (targetsMap[sourceType] = new List<GameRuleDesignComponentDescriptor>());
foreach (System.Type targetType in sourceAndTargets.Value) {
if (targetType == typeof(TeamPlayer))
targetsList.Add(teamPlayerDescriptor);
else if (targetType == typeof(Ball))
targetsList.Add(ballDescriptor);
else if (targetType == typeof(FieldObject))
targetsList.AddRange(fieldObjectDescriptors);
else
throw new System.Exception("Bug: invalid event source type " + sourceType);
}
}
}
//point descriptors for a points effect
List<GameRuleDesignComponentDescriptor> pointAmountSelection = (componentSelectionMap[typeof(GameRulePointsPlayerEffect)] = new List<GameRuleDesignComponentDescriptor>());
for (int i = GameRulePointsPlayerEffect.POINTS_SERIALIZATION_MAX_VALUE - GameRulePointsPlayerEffect.POINTS_SERIALIZATION_MASK;
i <= GameRulePointsPlayerEffect.POINTS_SERIALIZATION_MAX_VALUE;
i++) {
pointAmountSelection.Add(new GameRuleDesignComponentIntDescriptor(i));
}
//action durations
List<GameRuleDesignComponentDescriptor> gameRuleActionDurationSelection = (componentSelectionMap[typeof(GameRuleActionDuration)] = new List<GameRuleDesignComponentDescriptor>());
gameRuleActionDurationSelection.Add(new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleActionFixedDuration),
GameRuleIconStorage.instance.clockIcon, 0,
new System.Type[] {
//we'll just use this as the key for our list of possible second durations
typeof(GameRuleActionFixedDuration)
}));
gameRuleActionUntilConditionDurationDescriptor = new GameRuleDesignComponentClassDescriptor(
typeof(GameRuleActionUntilConditionDuration),
GameRuleIconStorage.instance.genericEventIcon, 0,
//we need an event happend condition but in a different form, we'll fill this in when this descriptor is assigned
null);
gameRuleActionDurationSelection.Add(gameRuleActionUntilConditionDurationDescriptor);
//now that we have our descriptors, we can build our selection map
//only some classes make easy popups, the others will need special handling
//duration length descriptors for fixed durations
List<GameRuleDesignComponentDescriptor> fixedDurationSelection = (componentSelectionMap[typeof(GameRuleActionFixedDuration)] = new List<GameRuleDesignComponentDescriptor>());
for (int i = 0; i <= GameRuleActionFixedDuration.DURATION_SERIALIZATION_MASK; i++) {
fixedDurationSelection.Add(new GameRuleDesignComponentIntDescriptor(i));
}
//for until-condition durations, each source type has a list of valid events that it can use
foreach (KeyValuePair<System.Type, List<GameRuleEventType>> sourceTypeWithEventTypes in GameRuleEvent.potentialEventTypesMap) {
List<GameRuleDesignComponentDescriptor> eventTypesForSource = (potentialEventsForSourceMap[sourceTypeWithEventTypes.Key] = new List<GameRuleDesignComponentDescriptor>());
foreach (GameRuleEventType eventType in sourceTypeWithEventTypes.Value) {
eventTypesForSource.Add(new GameRuleDesignComponentEventTypeDescriptor(eventType, 0));
}
}
//and finally we'll build our complete rule that the user can change
gameRuleConditionComponent = new GameRuleDesignComponent(null, typeof(GameRuleCondition));
gameRuleActionComponent = new GameRuleDesignComponent(null, gameRuleConditionComponent);
gameRuleComponent = new GameRuleDesignComponent(
null,
new GameRuleDesignComponentClassDescriptor(
typeof(GameRule),
GameRuleIconStorage.instance.resultsInIcon, 1, null));
gameRuleComponent.subComponents = new GameRuleDesignComponent[] {gameRuleConditionComponent, gameRuleActionComponent};
redisplayRule();
finishedInstantiating = true;
}
}
//build the popup from the given list of descriptors
//also receives the component that this popup will edit and the type of component used to find the descriptors
public void buildPopup(GameRuleDesignComponent cr, List<GameRuleDesignComponentDescriptor> pd, System.Type describedType)
{
//instead of Start(), this is the place where stuff will get initialized
//store a bunch of size information for positioning things
RectTransform iconArea = (RectTransform)(transform.GetChild(1));
iconAreaBottomLeft = iconArea.offsetMin;
iconAreaTopRight = iconArea.offsetMax; //x and y are both negative for an inset corner
iconAreaTotalBounds = iconAreaBottomLeft - iconAreaTopRight;
iconContainer = (RectTransform)(transform.GetChild(2));
//throw the container out to under the canvas so that it renders over the whole rule
iconContainer.SetParent(GameRuleDesigner.instance.uiCanvas);
RectTransform iconContainerSpacing = (RectTransform)(iconContainer.GetChild(0));
iconContainerSpacingSize = iconContainerSpacing.sizeDelta;
//we only needed these to get their size, we can get rid of them now
Destroy(iconArea.gameObject);
Destroy(iconContainerSpacing.gameObject);
//now we can build the popup
transform.SetParent(GameRuleDesigner.instance.iconContainerTransform);
//setting the parent screwed up the scale so fix it
transform.localScale = new Vector3(1.0f, 1.0f);
componentRepresented = cr;
popupDescriptors = pd;
//go through all the descriptors and add their icon to this popup
foreach (GameRuleDesignComponentDescriptor descriptor in popupDescriptors) {
RectTransform popupIcon;
//int descriptors don't have icon prefabs, so we have to construct the icons
if (descriptor is GameRuleDesignComponentIntDescriptor) {
List<GameObject> iconList = new List<GameObject>();
int i = ((GameRuleDesignComponentIntDescriptor)descriptor).intDescribed;
if (i >= 0) {
if (describedType == typeof(GameRulePointsPlayerEffect))
iconList.Add(GameRuleIconStorage.instance.charPlusIcon);
GameRuleIconStorage.instance.addDigitIcons(i, iconList);
} else {
iconList.Add(GameRuleIconStorage.instance.charMinusIcon);
GameRuleIconStorage.instance.addDigitIcons(-i, iconList);
}
//make a gameobject to hold all of the icons
popupIcon = groupIcons(iconList);
//almost all other descriptors we can construct normally
//if it doesn't have an icon then it's a special case we know about
} else if (descriptor.displayIcon == null) {
if (descriptor is GameRuleDesignComponentClassDescriptor) {
System.Type otherType = ((GameRuleDesignComponentClassDescriptor)descriptor).typeDescribed;
//a points effect shows up as "+?"
if (otherType == typeof(GameRulePointsPlayerEffect))
popupIcon = groupIcons(new List<GameObject>(new GameObject[] {
GameRuleIconStorage.instance.charPlusIcon,
GameRuleIconStorage.instance.charQmarkIcon
}));
else
throw new System.Exception("Bug: no special popup icon cases for type " + otherType);
} else
throw new System.Exception("Bug: no special popup icon cases for " + descriptor);
//it has an icon, it's probably normal
} else
popupIcon = componentRepresented.getIconMaybeOpponent(descriptor);
popupIcon.SetParent(iconContainer);
popupIcons.Add(popupIcon);
}
//we add a "cancel" icon at the end to ensure there's room to cancel out of the popup
RectTransform cancelIcon = instantiateIcon(GameRuleDesigner.instance.cancelIconPopupPrefab);
cancelIcon.SetParent(iconContainer);
popupIcons.Add(cancelIcon);
//if we're doing a points effect, default to the "+1" choice
if (describedType == typeof(GameRulePointsPlayerEffect))
cr.assignDescriptor(popupDescriptors[
GameRulePointsPlayerEffect.POINTS_SERIALIZATION_MASK - GameRulePointsPlayerEffect.POINTS_SERIALIZATION_MAX_VALUE + 1]);
//if we're doing a fixed duration, default to the rule generator min value
else if (describedType == typeof(GameRuleActionFixedDuration))
cr.assignDescriptor(popupDescriptors[GameRuleGenerator.ACTION_DURATION_SECONDS_SHORTEST]);
else
cr.assignDescriptor(popupDescriptors[0]);
}
//we need to do special initialization and we need to construct this without it doing anything
public GameRuleDesignComponent(GameRuleDesignComponent p)
{
parent = p;
}
public void assignDescriptor(GameRuleDesignComponentDescriptor newDescriptor)
{
//if there's no change then don't change anything
if (newDescriptor == descriptor)
return;
//if we're replacing a descriptor we need to get rid of everything it had
bool hadOldDescriptor = descriptor != null;
if (hadOldDescriptor)
destroyComponent(false);
descriptor = newDescriptor;
//if the descriptor is part of a popup then it will manage the icon
if (componentPopup != null)
componentIcon = componentPopup.setPopupIcon(newDescriptor);
//most components that are not part of a popup have an icon that represents it
else if (newDescriptor.displayIcon != null) {
componentIcon = getIconMaybeOpponent(newDescriptor);
componentIcon.SetParent(GameRuleDesigner.instance.iconContainerTransform);
componentIcon.localScale = new Vector3(1.0f, 1.0f);
}
//if it's got subcomponents, each one of them needs a popup
//we also need to pick a default for each one
//each event type has its own list that it will use
if (newDescriptor is GameRuleDesignComponentEventTypeDescriptor) {
GameRuleEventType eventType = ((GameRuleDesignComponentEventTypeDescriptor)newDescriptor).eventTypeDescribed;
//event-happened conditions and until-conditions both have event types
//based on which one this is, the structure of the subcomponents is different
//if we're in a regular event-happened condition, we have a source type and target type
if (parent.descriptor == GameRuleDesigner.instance.gameRuleEventHappenedConditionDurationDescriptor) {
//if we had an old descriptor, we want to check if the source type changed
System.Type oldSourceType;
if (hadOldDescriptor)
oldSourceType = ((GameRuleDesignComponentEventParticipantDescriptor)(subComponents[0].descriptor)).typeDescribed;
//otherwise, we need to initialize the subcomponents array
else {
oldSourceType = null;
subComponents = new GameRuleDesignComponent[2];
}
//constructing the component auto-assigns the target descriptor
(subComponents[0] = new GameRuleDesignComponent(this)).assignPopup(GameRuleDesigner.instance.potentialSourcesForEventMap[eventType], null);
if (hadOldDescriptor) {
System.Type newSourceType = ((GameRuleDesignComponentEventParticipantDescriptor)(subComponents[0].descriptor)).typeDescribed;
//the source type switched, we need to refresh the effect action's subcomponents
if (oldSourceType != newSourceType) {
GameRuleDesigner.instance.gameRuleActionComponent.destroyComponent(false);
GameRuleDesigner.instance.gameRuleActionComponent.assignEffectActionSelector(newSourceType);
}
}
//if we're in an until-condition duration, our parent is the source type and our only subcomponent is the target type
} else if (parent.parent.descriptor == GameRuleDesigner.instance.gameRuleActionUntilConditionDurationDescriptor) {
if (!hadOldDescriptor)
subComponents = new GameRuleDesignComponent[1];
subComponents[0] = new GameRuleDesignComponent(this, GameRuleDesigner.instance.potentialTargetsForEventSourceMap
[eventType]
//the source of the until-condition trigger is the target of a selector on the source of the original condition
[((GameRuleDesignComponentSelectorDescriptor)(parent.descriptor)).selectorDescribed.targetType()]);
} else
throw new System.Exception("Bug: event type changed with parent " + parent.descriptor);
//this is the source or the target of an event-happened-condition, which could be the condition or an until-condition duration
//if it's the condition, we need to change other stuff
} else if (newDescriptor is GameRuleDesignComponentEventParticipantDescriptor) {
//we changed the general condition source
//we need to update the target type and possibly also an action type
if (parent.parent.descriptor == GameRuleDesigner.instance.gameRuleEventHappenedConditionDurationDescriptor &&
parent.subComponents[0] == this) {
System.Type sourceType = ((GameRuleDesignComponentEventParticipantDescriptor)newDescriptor).typeDescribed;
//if the source changed from an old one then we need to update the action
//if this is the first time then the action gets set elsewhere
if (hadOldDescriptor) {
parent.subComponents[1].destroyComponent(true);
GameRuleDesigner.instance.gameRuleActionComponent.destroyComponent(false);
GameRuleDesigner.instance.gameRuleActionComponent.assignEffectActionSelector(sourceType);
}
parent.subComponents[1] = new GameRuleDesignComponent(parent, GameRuleDesigner.instance.potentialTargetsForEventSourceMap
[((GameRuleDesignComponentEventTypeDescriptor)(parent.descriptor)).eventTypeDescribed]
[sourceType]);
}
//when we assign an until-condition, we need to pick the source type and it will pick the event type which will pick the target type
} else if (descriptor == GameRuleDesigner.instance.gameRuleActionUntilConditionDurationDescriptor) {
subComponents = new GameRuleDesignComponent[] {
new GameRuleDesignComponent(this, GameRuleDesigner.instance.sourceSelectorMap[
((GameRuleDesignComponentEventParticipantDescriptor)(GameRuleDesigner.instance.gameRuleConditionComponent.subComponents[0].subComponents[0].descriptor)).typeDescribed])
};
//we changed a selector descriptor, this is an effect action, until-condition duration, or a zone source
} else if (newDescriptor is GameRuleDesignComponentSelectorDescriptor) {
System.Type parentType = ((GameRuleDesignComponentClassDescriptor)(parent.descriptor)).typeDescribed;
//when we change the selector for an effect action, we need to update the possible effects
if (parentType == typeof(GameRuleEffectAction)) {
if (hadOldDescriptor)
parent.subComponents[1].destroyComponent(true);
parent.subComponents[1] = new GameRuleDesignComponent(parent, GameRuleDesigner.instance.sourceEffectMap[
((GameRuleDesignComponentSelectorDescriptor)(newDescriptor)).selectorDescribed.targetType()]);
//we changed the source of an until-condition, we need to refresh the event type
} else if (parentType == typeof(GameRuleActionUntilConditionDuration)) {
subComponents = new GameRuleDesignComponent[] {
new GameRuleDesignComponent(this, GameRuleDesigner.instance.potentialEventsForSourceMap[
((GameRuleDesignComponentSelectorDescriptor)(descriptor)).selectorDescribed.targetType()])
};
}
//the rest of the descriptors build their subcomponents normally
} else if (newDescriptor.subComponents != null) {
subComponents = new GameRuleDesignComponent[newDescriptor.subComponents.Length];
for (int i = 0; i < subComponents.Length; i++) {
//the component will build itself from the popup types list
subComponents[i] = new GameRuleDesignComponent(this, newDescriptor.subComponents[i]);
}
//a few components need to send changes to other components
//zone type was changed, assign the right metarule
if (newDescriptor is GameRuleDesignComponentZoneTypeDescriptor) {
GameRuleRequiredObjectType zoneType = ((GameRuleDesignComponentZoneTypeDescriptor)newDescriptor).zoneTypeDescribed;
GameRuleDesigner.instance.gameRuleActionComponent.assignMetaRuleSubComponent(zoneType);
//the condition changed, update the action with the corresponding descriptor
} else if (this == GameRuleDesigner.instance.gameRuleConditionComponent) {
if (hadOldDescriptor)
GameRuleDesigner.instance.gameRuleActionComponent.complementComponent(this);
}
} else
subComponents = null;
//save the component that actually gets displayed to render this component
if (componentPopup != null)
componentDisplayed = (RectTransform)(componentPopup.transform);
else if (componentIcon != null)
componentDisplayed = componentIcon;
else
componentDisplayed = null;
}
//construct from a specific list of descriptors not obainable from the component selection map
public GameRuleDesignComponent(GameRuleDesignComponent p, List<GameRuleDesignComponentDescriptor> popupDescriptors)
{
parent = p;
assignPopup(popupDescriptors, null);
}
//this component is controlled by the other component
public GameRuleDesignComponent(GameRuleDesignComponent p, GameRuleDesignComponent otherComponent)
{
parent = p;
complementComponent(otherComponent);
}
//construct from a list of descriptors
//the variables for this component will change to reflect which component it represents
public GameRuleDesignComponent(GameRuleDesignComponent p, System.Type t)
{
parent = p;
assignPopup(GameRuleDesigner.instance.componentSelectionMap[t], t);
}
public void complementComponent(GameRuleDesignComponent otherComponent)
{
GameRuleDesignComponentDescriptor otherDescriptor = otherComponent.descriptor;
if (otherDescriptor is GameRuleDesignComponentClassDescriptor) {
System.Type otherType = ((GameRuleDesignComponentClassDescriptor)otherDescriptor).typeDescribed;
if (otherType == typeof(GameRuleEventHappenedCondition)) {
assignDescriptor(GameRuleDesigner.instance.gameRuleEffectActionDescriptor);
subComponents = new GameRuleDesignComponent[2];
assignEffectActionSelector(((GameRuleDesignComponentEventParticipantDescriptor)(otherComponent.subComponents[0].subComponents[0].descriptor)).typeDescribed);
} else if (otherType == typeof(GameRuleZoneCondition)) {
assignDescriptor(GameRuleDesigner.instance.gameRuleMetaRuleActionDescriptor);
subComponents = new GameRuleDesignComponent[1];
assignMetaRuleSubComponent(((GameRuleDesignComponentZoneTypeDescriptor)(otherComponent.subComponents[1].descriptor)).zoneTypeDescribed);
} else
throw new System.Exception("Bug: cannot complement design component descriptor type " + otherType);
} else
throw new System.Exception("Bug: cannot complement design component descriptor " + otherDescriptor);
}
public GameRuleDesignComponent(GameRuleDesignComponent p, GameRuleDesignComponentDescriptor d)
{
parent = p;
assignDescriptor(d);
}
public void assignMetaRuleSubComponent(GameRuleRequiredObjectType zoneType)
{
GameRuleDesignComponentMetaRuleDescriptor metaRuleDescriptor = (GameRuleDesignComponentMetaRuleDescriptor)(GameRuleDesigner.instance.zoneTypeMetaRuleMap[zoneType]);
GameRuleDesignComponent metaRuleComponent = new GameRuleDesignComponent(this, metaRuleDescriptor);
List<GameObject> iconList = new List<GameObject>();
metaRuleDescriptor.metaRuleDescribed.addIcons(iconList);
metaRuleComponent.componentDisplayed = (metaRuleComponent.componentIcon = GameRuleDesignPopup.groupIcons(iconList));
metaRuleComponent.componentIcon.SetParent(GameRuleDesigner.instance.iconContainerTransform);
metaRuleComponent.componentIcon.localScale = new Vector3(1.0f, 1.0f);
subComponents[0] = metaRuleComponent;
}
//set the source type for the effect action
//the process of doing that will set the effect
public void assignEffectActionSelector(System.Type sourceType)
{
subComponents[0] = new GameRuleDesignComponent(this, GameRuleDesigner.instance.sourceSelectorMap[sourceType]);
}