private AST createFromNodeType(int nodeTypeIndex)
{
Debug.Assert((nodeTypeIndex >= 0) && (nodeTypeIndex <= heteroList_.Length), "Invalid AST node type!");
AST newNode = null;
FactoryEntry entry = heteroList_[nodeTypeIndex];
if ((entry != null) && (entry.Creator != null))
{
newNode = entry.Creator.Create();
}
else
{
if ((entry == null) || (entry.NodeTypeObject == null))
{
if (defaultCreator_ == null)
{
newNode = createFromNodeTypeObject(defaultASTNodeTypeObject_);
}
else
{
newNode = defaultCreator_.Create();
}
}
else
{
newNode = createFromNodeTypeObject(entry.NodeTypeObject);
}
}
return(newNode);
}
/// <summary>
/// Register an ASTNodeCreator for a given Token type ID.
/// </summary>
/// <param name="NodeType">The Token type ID.</param>
/// <param name="creator">The creater to register.</param>
public void setTokenTypeASTNodeCreator(int NodeType, ASTNodeCreator creator)
{
// check validity of arguments...
if (NodeType < Token.MIN_USER_TYPE)
{
throw new ANTLRException("Internal parser error: Cannot change AST Node Type for Token ID '" + NodeType + "'");
}
// resize up to and including 'type' and initialize any gaps to default
// factory.
if (NodeType > (heteroList_.Length + 1))
{
setMaxNodeType(NodeType);
}
// And add new thing..
if (heteroList_[NodeType] == null)
{
heteroList_[NodeType] = new FactoryEntry(creator);
}
else
{
heteroList_[NodeType].Creator = creator;
}
//typename2creator_[NodeType.ToString()] = creator;
typename2creator_[creator.ASTNodeTypeName] = creator;
}
/// <summary>
/// Pre-expands the internal list of TokenTypeID-to-ASTNodeType mappings
/// to the specified size.
/// This is primarily a convenience method that can be used to prevent
/// unnecessary and costly re-org of the mappings list.
/// </summary>
/// <param name="NodeType">Maximum Token Type ID.</param>
public void setMaxNodeType(int NodeType)
{
//Debug.WriteLine(this, "NodeType = " + NodeType + " and NodeList.Length = " + nodeTypeList_.Length);
if (heteroList_ == null)
{
heteroList_ = new FactoryEntry[NodeType + 1];
}
else
{
int length = heteroList_.Length;
if (NodeType > (length + 1))
{
FactoryEntry[] newList = new FactoryEntry[NodeType + 1];
Array.Copy(heteroList_, 0, newList, 0, heteroList_.Length);
heteroList_ = newList;
}
else if (NodeType < (length + 1))
{
FactoryEntry[] newList = new FactoryEntry[NodeType + 1];
Array.Copy(heteroList_, 0, newList, 0, (NodeType + 1));
heteroList_ = newList;
}
}
//Debug.WriteLine(this, "NodeType = " + NodeType + " and NodeList.Length = " + nodeTypeList_.Length);
}
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject entity in _cells)
{
Cell cell = entity.GetComponent <Cell>();
if (!cell.state.Equals(CellState.DEAD))
{
GameObject[] targets = entity.GetComponent <InCollision3D>().Targets;
foreach (GameObject target in targets)
{
if (target.activeSelf && target.GetComponent <Removed>() == null && target.GetComponent <Infectious>() != null)
{
FactoryEntry infection = new FactoryEntry(target)
{
originalNb = 1,
nb = 1
};
cell.infections.Add(infection);
target.SetActive(false);
target.transform.parent = entity.transform;
}
}
}
}
}
/// <summary>
/// Constructs an <c>ASTFactory</c> and use the specified AST node type
/// as the default.
/// </summary>
/// <param name="defaultASTNodeType">Node type for this factory.</param>
public ASTFactory(Type defaultASTNodeType)
{
heteroList_ = new FactoryEntry[Token.MIN_USER_TYPE + 1];
defaultASTNodeTypeObject_ = defaultASTNodeType;
defaultCreator_ = null;
typename2creator_ = new Hashtable(32, (float)0.3);
typename2creator_["antlr.CommonAST"] = CommonAST.Creator;
typename2creator_["antlr.CommonASTWithHiddenTokens"] = CommonASTWithHiddenTokens.Creator;
}
/// <summary>
/// Constructs an <c>ASTFactory</c> and use the specified AST node type
/// as the default.
/// </summary>
/// <param name="defaultASTNodeType">Node type for this factory.</param>
public ASTFactory(Type defaultASTNodeType)
{
heteroList_ = new FactoryEntry[Token.MIN_USER_TYPE+1];
defaultASTNodeTypeObject_ = defaultASTNodeType;
defaultCreator_ = null;
typename2creator_ = new Hashtable(32, (float) 0.3);
typename2creator_["antlr.CommonAST"] = CommonAST.Creator;
typename2creator_["antlr.CommonASTWithHiddenTokens"] = CommonASTWithHiddenTokens.Creator;
}
//---------------------------------------------------------------------
// FUNCTION MEMBERS
//---------------------------------------------------------------------
/// <summary>
/// Specify an "override" for the <see cref="AST"/> type created for
/// the specified Token type.
/// </summary>
/// <remarks>
/// This method is useful for situations that ANTLR cannot oridinarily deal
/// with (i.e., when you create a token based upon a nonliteral token symbol
/// like #[LT(1)]. This is a runtime value and ANTLR cannot determine the token
/// type (and hence the AST) statically.
/// </remarks>
/// <param name="tokenType">Token type to override.</param>
/// <param name="NodeTypeName">
/// Fully qualified AST typename (or null to specify
/// the factory's default AST type).
/// </param>
public void setTokenTypeASTNodeType(int tokenType, string NodeTypeName)
{
// check validity of arguments...
if (tokenType < Token.MIN_USER_TYPE)
{
throw new ANTLRException("Internal parser error: Cannot change AST Node Type for Token ID '" + tokenType + "'");
}
// resize up to and including 'type' and initialize any gaps to default
// factory.
if (tokenType > (heteroList_.Length + 1))
{
setMaxNodeType(tokenType);
}
// And add new thing..
if (heteroList_[tokenType] == null)
{
heteroList_[tokenType] = new FactoryEntry(loadNodeTypeObject(NodeTypeName));
}
else
{
heteroList_[tokenType].NodeTypeObject = loadNodeTypeObject(NodeTypeName);
}
}
/// <summary>
/// Pre-expands the internal list of TokenTypeID-to-ASTNodeType mappings
/// to the specified size.
/// This is primarily a convenience method that can be used to prevent
/// unnecessary and costly re-org of the mappings list.
/// </summary>
/// <param name="NodeType">Maximum Token Type ID.</param>
public void setMaxNodeType( int NodeType )
{
//Debug.WriteLine(this, "NodeType = " + NodeType + " and NodeList.Length = " + nodeTypeList_.Length);
if (heteroList_ == null)
{
heteroList_ = new FactoryEntry[NodeType+1];
}
else
{
int length = heteroList_.Length;
if ( NodeType >= length )
{
FactoryEntry[] newList = new FactoryEntry[NodeType+1];
Array.Copy(heteroList_, 0, newList, 0, length);
heteroList_ = newList;
}
else if ( NodeType < length )
{
FactoryEntry[] newList = new FactoryEntry[NodeType+1];
Array.Copy(heteroList_, 0, newList, 0, (NodeType+1));
heteroList_ = newList;
}
}
//Debug.WriteLine(this, "NodeType = " + NodeType + " and NodeList.Length = " + nodeTypeList_.Length);
}
/// <summary>
/// Register an ASTNodeCreator for a given Token type ID.
/// </summary>
/// <param name="NodeType">The Token type ID.</param>
/// <param name="creator">The creater to register.</param>
public void setTokenTypeASTNodeCreator(int NodeType, ASTNodeCreator creator)
{
// check validity of arguments...
if( NodeType < Token.MIN_USER_TYPE )
throw new ANTLRException("Internal parser error: Cannot change AST Node Type for Token ID '" + NodeType + "'");
// resize up to and including 'type' and initialize any gaps to default
// factory.
if (NodeType > (heteroList_.Length+1))
setMaxNodeType(NodeType);
// And add new thing..
if (heteroList_[NodeType] == null)
heteroList_[NodeType] = new FactoryEntry(creator);
else
heteroList_[NodeType].Creator = creator;
//typename2creator_[NodeType.ToString()] = creator;
typename2creator_[creator.ASTNodeTypeName] = creator;
}
//---------------------------------------------------------------------
// FUNCTION MEMBERS
//---------------------------------------------------------------------
/// <summary>
/// Specify an "override" for the <see cref="AST"/> type created for
/// the specified Token type.
/// </summary>
/// <remarks>
/// This method is useful for situations that ANTLR cannot oridinarily deal
/// with (i.e., when you create a token based upon a nonliteral token symbol
/// like #[LT(1)]. This is a runtime value and ANTLR cannot determine the token
/// type (and hence the AST) statically.
/// </remarks>
/// <param name="tokenType">Token type to override.</param>
/// <param name="NodeTypeName">
/// Fully qualified AST typename (or null to specify
/// the factory's default AST type).
/// </param>
public void setTokenTypeASTNodeType(int tokenType, string NodeTypeName)
{
// check validity of arguments...
if( tokenType < Token.MIN_USER_TYPE )
throw new ANTLRException("Internal parser error: Cannot change AST Node Type for Token ID '" + tokenType + "'");
// resize up to and including 'type' and initialize any gaps to default
// factory.
if (tokenType > (heteroList_.Length+1))
setMaxNodeType(tokenType);
// And add new thing..
if (heteroList_[tokenType] == null)
heteroList_[tokenType] = new FactoryEntry(loadNodeTypeObject(NodeTypeName));
else
heteroList_[tokenType].NodeTypeObject = loadNodeTypeObject(NodeTypeName);
}
public void SetInterceptedComponentModel(ComponentModel target)
{
entry = (FactoryEntry)target.ExtendedProperties["typed.fac.entry"];
}
public void SetInterceptedComponentModel(ComponentModel target)
{
entry = (FactoryEntry) target.ExtendedProperties["typed.fac.entry"];
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _factories)
{
Factory factory = go.GetComponent <Factory>();
// Is the factory working ? Should it be destroyed ?
if (!AtLeastOneThingToInstanciate(factory.entries))
{
GameObjectManager.unbind(go);
Object.Destroy(go);
continue;
}
if (factory.paused)
{
continue;
}
// Update remaining time and skip instanciation process if we still have to wait
factory.remaining -= Time.deltaTime;
if (factory.remaining > 0)
{
continue;
}
// Select the entity that will be created (according to factory's mode)
FactoryEntry entry = null;
if (factory.useRandomSpawning)
{
do
{
entry = factory.entries[Random.Range(0, factory.entries.Count)];
} while (entry.nb == 0);
}
else
{
int i = 0;
do
{
entry = factory.entries[i];
++i;
} while (entry.nb == 0);
}
// Instanciate the GameObject
GameObject clone = Object.Instantiate(entry.prefab);
clone.SetActive(true);
//clone.layer = entry.layer;
clone.layer = LayerMask.NameToLayer("Pathogene");
// Bind it to FYFY
GameObjectManager.bind(clone);
// Set GameObject's position
clone.transform.position = go.transform.position;
// Decrease the number of remaining object to instanciate (for this prefab)
--entry.nb;
// Reset remaining time to rate
factory.remaining = factory.rate;
}
}
