repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotEmptyCell.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific cell that must NOT be empty
*
* @author Dennis Soemers
*/
public class SingleMustNotEmptyCell extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The site that must be empty */
protected final int mustNotEmptySite;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotEmptySite
*/
public SingleMustNotEmptyCell(final int mustNotEmptySite)
{
this.mustNotEmptySite = mustNotEmptySite;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].emptyChunkSetCell().get(mustNotEmptySite);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Cell;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.set(mustNotEmptySite);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Empty;
}
@Override
public int testedSite()
{
return mustNotEmptySite;
}
@Override
public int value()
{
return 1;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not empty, we prove not empty
return (other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not empty, we disprove empty
return (other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not not empty, we prove empty
if (other.stateVectorType() == StateVectorTypes.Empty)
return !other.negated();
// If not not empty, we prove that it's not friend, not enemy, not piece 1, not piece 2, etc.
return (other.stateVectorType() != StateVectorTypes.Empty && other.value() > 0 && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not not empty, we disprove not empty
if (other.stateVectorType() == StateVectorTypes.Empty)
return other.negated();
// If not not empty, we disprove friend, enemy, piece 1, piece 2, etc.
return (other.stateVectorType() != StateVectorTypes.Empty && other.value() > 0 && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + mustNotEmptySite;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotEmptyCell))
return false;
final SingleMustNotEmptyCell other = (SingleMustNotEmptyCell) obj;
return (mustNotEmptySite == other.mustNotEmptySite);
}
@Override
public String toString()
{
return "[Cell " + mustNotEmptySite + " must NOT be empty]";
}
//-------------------------------------------------------------------------
}
| 4,215 | 21.306878 | 102 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotEmptyEdge.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific edge that must NOT be empty
*
* @author Dennis Soemers
*/
public class SingleMustNotEmptyEdge extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The site that must be empty */
protected final int mustNotEmptySite;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotEmptySite
*/
public SingleMustNotEmptyEdge(final int mustNotEmptySite)
{
this.mustNotEmptySite = mustNotEmptySite;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].emptyChunkSetEdge().get(mustNotEmptySite);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Edge;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.set(mustNotEmptySite);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Empty;
}
@Override
public int testedSite()
{
return mustNotEmptySite;
}
@Override
public int value()
{
return 1;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not empty, we prove not empty
return (other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not empty, we disprove empty
return (other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not not empty, we prove empty
if (other.stateVectorType() == StateVectorTypes.Empty)
return !other.negated();
// If not not empty, we prove that it's not friend, not enemy, not piece 1, not piece 2, etc.
return (other.stateVectorType() != StateVectorTypes.Empty && other.value() > 0 && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not not empty, we disprove not empty
if (other.stateVectorType() == StateVectorTypes.Empty)
return other.negated();
// If not not empty, we disprove friend, enemy, piece 1, piece 2, etc.
return (other.stateVectorType() != StateVectorTypes.Empty && other.value() > 0 && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + mustNotEmptySite;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotEmptyEdge))
return false;
final SingleMustNotEmptyEdge other = (SingleMustNotEmptyEdge) obj;
return (mustNotEmptySite == other.mustNotEmptySite);
}
@Override
public String toString()
{
return "[Edge " + mustNotEmptySite + " must NOT be empty]";
}
//-------------------------------------------------------------------------
}
| 4,215 | 21.306878 | 102 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotEmptyVertex.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific vertex that must NOT be empty
*
* @author Dennis Soemers
*/
public class SingleMustNotEmptyVertex extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The site that must be empty */
protected final int mustNotEmptySite;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotEmptySite
*/
public SingleMustNotEmptyVertex(final int mustNotEmptySite)
{
this.mustNotEmptySite = mustNotEmptySite;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].emptyChunkSetVertex().get(mustNotEmptySite);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Vertex;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.set(mustNotEmptySite);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Empty;
}
@Override
public int testedSite()
{
return mustNotEmptySite;
}
@Override
public int value()
{
return 1;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not empty, we prove not empty
return (other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not empty, we disprove empty
return (other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not not empty, we prove empty
if (other.stateVectorType() == StateVectorTypes.Empty)
return !other.negated();
// If not not empty, we prove that it's not friend, not enemy, not piece 1, not piece 2, etc.
return (other.stateVectorType() != StateVectorTypes.Empty && other.value() > 0 && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not not empty, we disprove not empty
if (other.stateVectorType() == StateVectorTypes.Empty)
return other.negated();
// If not not empty, we disprove friend, enemy, piece 1, piece 2, etc.
return (other.stateVectorType() != StateVectorTypes.Empty && other.value() > 0 && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + mustNotEmptySite;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotEmptyVertex))
return false;
final SingleMustNotEmptyVertex other = (SingleMustNotEmptyVertex) obj;
return (mustNotEmptySite == other.mustNotEmptySite);
}
@Override
public String toString()
{
return "[Vertex " + mustNotEmptySite + " must NOT be empty]";
}
//-------------------------------------------------------------------------
}
| 4,233 | 21.402116 | 102 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotWhatCell.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific cell that must NOT contain a specific value
*
* @author Dennis Soemers
*/
public class SingleMustNotWhatCell extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotWhatSite
* @param mustNotWhatValue
* @param chunkSize
*/
public SingleMustNotWhatCell(final int mustNotWhatSite, final int mustNotWhatValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustNotWhatSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustNotWhatValue) << up);
this.site = mustNotWhatSite;
this.value = mustNotWhatValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].matchesWhatCell(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Cell;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.What;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If the tested piece type is the only one owned by its player, we can
// infer not who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
{
// owner of piece doesn't own any other pieces, so can infer that Who is not equal to owner
return (other.stateVectorType() == StateVectorTypes.Who && other.negated() && other.value() == game.equipment().components()[value()].owner());
}
return false;
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If the tested piece type is the only one owned by its player, we can
// infer not who for that owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
{
// owner of piece doesn't own any other pieces, so can disprove that Who is equal to owner
return (!other.negated() && other.value() == game.equipment().components()[value()].owner());
}
// Not containing a specific piece disproves that we contain that same specific piece
return (other.stateVectorType() == StateVectorTypes.What && other.value() == value());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain a specific piece, so we prove that we contain it
if (other.stateVectorType() == StateVectorTypes.What)
return (!other.negated() && value() == other.value());
// If we DO contain this specific piece, and if it's the only one owned by its owner, we prove who = owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
return (!other.negated() && other.value() == game.equipment().components()[value()].owner());
// False means we DO contain a specific piece, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain a specific piece, so we disprove that we don't contain it
if (other.stateVectorType() == StateVectorTypes.What)
return (other.negated() && value() == other.value());
// If we DO contain this specific piece, and if it's the only one owned by its owner, we disprove who =/= owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
return (other.negated() && other.value() == game.equipment().components()[value()].owner());
// False means we DO contain a specific piece, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotWhatCell))
return false;
final SingleMustNotWhatCell other = (SingleMustNotWhatCell) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Cell " + site + " must NOT contain " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,653 | 27.075949 | 146 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotWhatEdge.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific cell that must NOT contain a specific value
*
* @author Dennis Soemers
*/
public class SingleMustNotWhatEdge extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotWhatSite
* @param mustNotWhatValue
* @param chunkSize
*/
public SingleMustNotWhatEdge(final int mustNotWhatSite, final int mustNotWhatValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustNotWhatSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustNotWhatValue) << up);
this.site = mustNotWhatSite;
this.value = mustNotWhatValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].matchesWhatEdge(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Edge;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.What;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If the tested piece type is the only one owned by its player, we can
// infer not who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
{
// owner of piece doesn't own any other pieces, so can infer that Who is not equal to owner
return (other.stateVectorType() == StateVectorTypes.Who && other.negated() && other.value() == game.equipment().components()[value()].owner());
}
return false;
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If the tested piece type is the only one owned by its player, we can
// infer not who for that owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
{
// owner of piece doesn't own any other pieces, so can disprove that Who is equal to owner
return (!other.negated() && other.value() == game.equipment().components()[value()].owner());
}
// Not containing a specific piece disproves that we contain that same specific piece
return (other.stateVectorType() == StateVectorTypes.What && other.value() == value());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain a specific piece, so we prove that we contain it
if (other.stateVectorType() == StateVectorTypes.What)
return (!other.negated() && value() == other.value());
// If we DO contain this specific piece, and if it's the only one owned by its owner, we prove who = owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
return (!other.negated() && other.value() == game.equipment().components()[value()].owner());
// False means we DO contain a specific piece, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain a specific piece, so we disprove that we don't contain it
if (other.stateVectorType() == StateVectorTypes.What)
return (other.negated() && value() == other.value());
// If we DO contain this specific piece, and if it's the only one owned by its owner, we disprove who =/= owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
return (other.negated() && other.value() == game.equipment().components()[value()].owner());
// False means we DO contain a specific piece, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotWhatEdge))
return false;
final SingleMustNotWhatEdge other = (SingleMustNotWhatEdge) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Edge " + site + " must NOT contain " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,653 | 27.075949 | 146 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotWhatVertex.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific vertex that must NOT contain a specific value
*
* @author Dennis Soemers
*/
public class SingleMustNotWhatVertex extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotWhatSite
* @param mustNotWhatValue
* @param chunkSize
*/
public SingleMustNotWhatVertex(final int mustNotWhatSite, final int mustNotWhatValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustNotWhatSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustNotWhatValue) << up);
this.site = mustNotWhatSite;
this.value = mustNotWhatValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].matchesWhatVertex(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Vertex;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.What;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If the tested piece type is the only one owned by its player, we can
// infer not who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
{
// owner of piece doesn't own any other pieces, so can infer that Who is not equal to owner
return (other.stateVectorType() == StateVectorTypes.Who && other.negated() && other.value() == game.equipment().components()[value()].owner());
}
return false;
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If the tested piece type is the only one owned by its player, we can
// infer not who for that owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
{
// owner of piece doesn't own any other pieces, so can disprove that Who is equal to owner
return (!other.negated() && other.value() == game.equipment().components()[value()].owner());
}
// Not containing a specific piece disproves that we contain that same specific piece
return (other.stateVectorType() == StateVectorTypes.What && other.value() == value());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain a specific piece, so we prove that we contain it
if (other.stateVectorType() == StateVectorTypes.What)
return (!other.negated() && value() == other.value());
// If we DO contain this specific piece, and if it's the only one owned by its owner, we prove who = owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
return (!other.negated() && other.value() == game.equipment().components()[value()].owner());
// False means we DO contain a specific piece, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain a specific piece, so we disprove that we don't contain it
if (other.stateVectorType() == StateVectorTypes.What)
return (other.negated() && value() == other.value());
// If we DO contain this specific piece, and if it's the only one owned by its owner, we disprove who =/= owner
if (other.stateVectorType() == StateVectorTypes.Who && AtomicProposition.ownerOnlyOwns(game, value()))
return (other.negated() && other.value() == game.equipment().components()[value()].owner());
// False means we DO contain a specific piece, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotWhatVertex))
return false;
final SingleMustNotWhatVertex other = (SingleMustNotWhatVertex) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Vertex " + site + " must NOT contain " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,672 | 27.156118 | 146 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotWhoCell.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific cell that must be not owned by a specific player
*
* @author Dennis Soemers
*/
public class SingleMustNotWhoCell extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotWhoSite
* @param mustNotWhoValue
* @param chunkSize
*/
public SingleMustNotWhoCell(final int mustNotWhoSite, final int mustNotWhoValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustNotWhoSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustNotWhoValue) << up);
this.site = mustNotWhoSite;
this.value = mustNotWhoValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
assert
(
state.containerStates()[0].matchesWhoCell(wordIdx, mask, matchingWord)
==
(state.containerStates()[0].whoCell(site) == value)
);
return !state.containerStates()[0].matchesWhoCell(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Cell;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Who;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not who is true, we also prove not what for any what owned by the player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not who is true, we disprove what for any what owned by the player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// Not containing a specific player disproves that we contain that same specific player
return (other.stateVectorType() == StateVectorTypes.Who && other.value() == value());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (!other.negated() && value() == other.value());
// If the tested player only owns a single piece type, we also prove what for that piece type
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.playerOnlyOwns(game, value(), other.value()));
// We prove not-what for any what not owned by player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (!AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// False means we DO contain a specific player, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && value() == other.value());
// If player owns only a single piece type, we disprove not-what for that piece type
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.playerOnlyOwns(game, value(), other.value()));
// We disprove what for any what not owned by this player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (!AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// False means we DO contain a specific player, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotWhoCell))
return false;
final SingleMustNotWhoCell other = (SingleMustNotWhoCell) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Cell " + site + " must NOT be owned by Player " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,713 | 26.516393 | 102 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotWhoEdge.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific edge that must be not owned by a specific player
*
* @author Dennis Soemers
*/
public class SingleMustNotWhoEdge extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotWhoSite
* @param mustNotWhoValue
* @param chunkSize
*/
public SingleMustNotWhoEdge(final int mustNotWhoSite, final int mustNotWhoValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustNotWhoSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustNotWhoValue) << up);
this.site = mustNotWhoSite;
this.value = mustNotWhoValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].matchesWhoEdge(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Edge;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Who;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not who is true, we also prove not what for any what owned by the player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not who is true, we disprove what for any what owned by the player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// Not containing a specific player disproves that we contain that same specific player
return (other.stateVectorType() == StateVectorTypes.Who && other.value() == value());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (!other.negated() && value() == other.value());
// If the tested player only owns a single piece type, we also prove what for that piece type
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.playerOnlyOwns(game, value(), other.value()));
// We prove not-what for any what not owned by player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (!AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// False means we DO contain a specific player, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && value() == other.value());
// If player owns only a single piece type, we disprove not-what for that piece type
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.playerOnlyOwns(game, value(), other.value()));
// We disprove what for any what not owned by this player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (!AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// False means we DO contain a specific player, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotWhoEdge))
return false;
final SingleMustNotWhoEdge other = (SingleMustNotWhoEdge) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Edge " + site + " must NOT be owned by Player " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,556 | 26.666667 | 102 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustNotWhoVertex.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific cell that must be not owned by a specific player
*
* @author Dennis Soemers
*/
public class SingleMustNotWhoVertex extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustNotWhoSite
* @param mustNotWhoValue
* @param chunkSize
*/
public SingleMustNotWhoVertex(final int mustNotWhoSite, final int mustNotWhoValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustNotWhoSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustNotWhoValue) << up);
this.site = mustNotWhoSite;
this.value = mustNotWhoValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return !state.containerStates()[0].matchesWhoVertex(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Vertex;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Who;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return true;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not who is true, we also prove not what for any what owned by the player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If not who is true, we disprove what for any what owned by the player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// Not containing a specific player disproves that we contain that same specific player
return (other.stateVectorType() == StateVectorTypes.Who && other.value() == value());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (!other.negated() && value() == other.value());
// If the tested player only owns a single piece type, we also prove what for that piece type
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.playerOnlyOwns(game, value(), other.value()));
// We prove not-what for any what not owned by player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (!AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// False means we DO contain a specific player, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// False means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && value() == other.value());
// If player owns only a single piece type, we disprove not-what for that piece type
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.playerOnlyOwns(game, value(), other.value()));
// We disprove what for any what not owned by this player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (!AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
// False means we DO contain a specific player, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustNotWhoVertex))
return false;
final SingleMustNotWhoVertex other = (SingleMustNotWhoVertex) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Vertex " + site + " must NOT be owned by Player " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,573 | 26.738397 | 104 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustWhatCell.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific cell that must contain a specific value
*
* @author Dennis Soemers
*/
public class SingleMustWhatCell extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustWhatSite
* @param mustWhatValue
* @param chunkSize
*/
public SingleMustWhatCell(final int mustWhatSite, final int mustWhatValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustWhatSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustWhatValue) << up);
this.site = mustWhatSite;
this.value = mustWhatValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return state.containerStates()[0].matchesWhatCell(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return true;
}
@Override
public SiteType graphElementType()
{
return SiteType.Cell;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.What;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return false;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain a specific piece, so we prove that we contain it and prove that we do NOT contain something else
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (value() != other.value());
else
return (value() == other.value());
}
// We prove who for owner of piece type, and not who for any other player
if (other.stateVectorType() == StateVectorTypes.Who)
{
if (other.negated())
return (other.value() != game.equipment().components()[value()].owner());
else
return (other.value() == game.equipment().components()[value()].owner());
}
// True means we DO contain a specific piece, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain a specific piece, so we disprove that we don't contain it, and disprove containing any other piece
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (value() == other.value());
else
return (value() != other.value());
}
// We disprove not who for owner, and who for any other player
if (other.stateVectorType() == StateVectorTypes.Who)
{
if (other.negated())
return (other.value() == game.equipment().components()[value()].owner());
else
return (other.value() != game.equipment().components()[value()].owner());
}
// True means we DO contain a specific piece, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If this is the only piece type owned by its owner, we prove not-who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
return (other.stateVectorType() == StateVectorTypes.Who && other.negated() && other.value() == game.equipment().components()[value()].owner());
return false;
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If this is the only piece type owned by its owner, we disprove who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
return (other.stateVectorType() == StateVectorTypes.Who && !other.negated() && other.value() == game.equipment().components()[value()].owner());
return false;
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustWhatCell))
return false;
final SingleMustWhatCell other = (SingleMustWhatCell) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Cell " + site + " must contain " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,421 | 24.895161 | 147 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustWhatEdge.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific edge that must contain a specific value
*
* @author Dennis Soemers
*/
public class SingleMustWhatEdge extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustWhatSite
* @param mustWhatValue
* @param chunkSize
*/
public SingleMustWhatEdge(final int mustWhatSite, final int mustWhatValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustWhatSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustWhatValue) << up);
this.site = mustWhatSite;
this.value = mustWhatValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return state.containerStates()[0].matchesWhatEdge(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return true;
}
@Override
public SiteType graphElementType()
{
return SiteType.Edge;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.What;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return false;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain a specific piece, so we prove that we contain it and prove that we do NOT contain something else
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (value() != other.value());
else
return (value() == other.value());
}
// We prove who for owner of piece type, and not who for any other player
if (other.stateVectorType() == StateVectorTypes.Who)
{
if (other.negated())
return (other.value() != game.equipment().components()[value()].owner());
else
return (other.value() == game.equipment().components()[value()].owner());
}
// True means we DO contain a specific piece, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain a specific piece, so we disprove that we don't contain it, and disprove containing any other piece
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (value() == other.value());
else
return (value() != other.value());
}
// We disprove not who for owner, and who for any other player
if (other.stateVectorType() == StateVectorTypes.Who)
{
if (other.negated())
return (other.value() == game.equipment().components()[value()].owner());
else
return (other.value() != game.equipment().components()[value()].owner());
}
// True means we DO contain a specific piece, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If this is the only piece type owned by its owner, we prove not-who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
return (other.stateVectorType() == StateVectorTypes.Who && other.negated() && other.value() == game.equipment().components()[value()].owner());
return false;
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If this is the only piece type owned by its owner, we disprove who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
return (other.stateVectorType() == StateVectorTypes.Who && !other.negated() && other.value() == game.equipment().components()[value()].owner());
return false;
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustWhatEdge))
return false;
final SingleMustWhatEdge other = (SingleMustWhatEdge) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Edge " + site + " must contain " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,421 | 24.895161 | 147 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustWhatVertex.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific vertex that must contain a specific value
*
* @author Dennis Soemers
*/
public class SingleMustWhatVertex extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustWhatSite
* @param mustWhatValue
* @param chunkSize
*/
public SingleMustWhatVertex(final int mustWhatSite, final int mustWhatValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustWhatSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustWhatValue) << up);
this.site = mustWhatSite;
this.value = mustWhatValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return state.containerStates()[0].matchesWhatVertex(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return true;
}
@Override
public SiteType graphElementType()
{
return SiteType.Vertex;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.What;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return false;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain a specific piece, so we prove that we contain it and prove that we do NOT contain something else
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (value() != other.value());
else
return (value() == other.value());
}
// We prove who for owner of piece type, and not who for any other player
if (other.stateVectorType() == StateVectorTypes.Who)
{
if (other.negated())
return (other.value() != game.equipment().components()[value()].owner());
else
return (other.value() == game.equipment().components()[value()].owner());
}
// True means we DO contain a specific piece, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain a specific piece, so we disprove that we don't contain it, and disprove containing any other piece
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (value() == other.value());
else
return (value() != other.value());
}
// We disprove not who for owner, and who for any other player
if (other.stateVectorType() == StateVectorTypes.Who)
{
if (other.negated())
return (other.value() == game.equipment().components()[value()].owner());
else
return (other.value() != game.equipment().components()[value()].owner());
}
// True means we DO contain a specific piece, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If this is the only piece type owned by its owner, we prove not-who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
return (other.stateVectorType() == StateVectorTypes.Who && other.negated() && other.value() == game.equipment().components()[value()].owner());
return false;
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// If this is the only piece type owned by its owner, we disprove who for that owner
if (AtomicProposition.ownerOnlyOwns(game, value()))
return (other.stateVectorType() == StateVectorTypes.Who && !other.negated() && other.value() == game.equipment().components()[value()].owner());
return false;
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustWhatVertex))
return false;
final SingleMustWhatVertex other = (SingleMustWhatVertex) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Vertex " + site + " must contain " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,439 | 24.967742 | 147 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustWhoCell.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific cell that must be owned by a specific player
*
* @author Dennis Soemers
*/
public class SingleMustWhoCell extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustWhoSite
* @param mustWhoValue
* @param chunkSize
*/
public SingleMustWhoCell(final int mustWhoSite, final int mustWhoValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustWhoSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustWhoValue) << up);
this.site = mustWhoSite;
this.value = mustWhoValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return state.containerStates()[0].matchesWhoCell(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return true;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Cell;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Who;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return false;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (!other.negated() && value() == other.value());
// We prove not-what for any piece not owned by player, and also prove what if this player only owns a single piece type
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (game.equipment().components()[other.value()].owner() != value());
else
return AtomicProposition.playerOnlyOwns(game, value(), other.value());
}
// True means we DO contain a specific player, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && value() == other.value());
// We disprove what for any piece not owned by player, and also disprove not-what for piece if player only owns a single piece type
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return AtomicProposition.playerOnlyOwns(game, value(), other.value());
else
return (game.equipment().components()[other.value()].owner() != value());
}
// True means we DO contain a specific player, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// We prove not-who
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && other.value() == value());
// We prove not-what for any what owned by this player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// We disprove what for any what owned by this player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustWhoCell))
return false;
final SingleMustWhoCell other = (SingleMustWhoCell) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Cell " + site + " must be owned by Player " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,254 | 24.847107 | 133 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustWhoEdge.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific edge that must be owned by a specific player
*
* @author Dennis Soemers
*/
public class SingleMustWhoEdge extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustWhoSite
* @param mustWhoValue
* @param chunkSize
*/
public SingleMustWhoEdge(final int mustWhoSite, final int mustWhoValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustWhoSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustWhoValue) << up);
this.site = mustWhoSite;
this.value = mustWhoValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
return state.containerStates()[0].matchesWhoEdge(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return true;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Edge;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Who;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return false;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (!other.negated() && value() == other.value());
// We prove not-what for any piece not owned by player, and also prove what if this player only owns a single piece type
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (game.equipment().components()[other.value()].owner() != value());
else
return AtomicProposition.playerOnlyOwns(game, value(), other.value());
}
// True means we DO contain a specific player, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && value() == other.value());
// We disprove what for any piece not owned by player, and also disprove not-what for piece if player only owns a single piece type
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return AtomicProposition.playerOnlyOwns(game, value(), other.value());
else
return (game.equipment().components()[other.value()].owner() != value());
}
// True means we DO contain a specific player, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// We prove not-who
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && other.value() == value());
// We prove not-what for any what owned by this player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// We disprove what for any what owned by this player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustWhoEdge))
return false;
final SingleMustWhoEdge other = (SingleMustWhoEdge) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Edge " + site + " must be owned by Player " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,254 | 24.847107 | 133 |
java
|
Ludii
|
Ludii-master/Features/src/features/spatial/instances/SingleMustWhoVertex.java
|
package features.spatial.instances;
import game.Game;
import game.types.board.SiteType;
import main.collections.ChunkSet;
import other.state.State;
/**
* A test that check for a single specific vertex that must be owned by a specific player
*
* @author Dennis Soemers
*/
public class SingleMustWhoVertex extends AtomicProposition
{
//-------------------------------------------------------------------------
/** The index of the word that we want to match */
protected final int wordIdx;
/** The mask that we want to apply to the word when matching */
protected final long mask;
/** The word that we should match after masking */
protected final long matchingWord;
/** The site we look at */
protected final int site;
/** The value we look for in chunkset */
protected final int value;
//-------------------------------------------------------------------------
/**
* Constructor
* @param mustWhoSite
* @param mustWhoValue
* @param chunkSize
*/
public SingleMustWhoVertex(final int mustWhoSite, final int mustWhoValue, final int chunkSize)
{
// Using same logic as ChunkSet.setChunk() here to determine wordIdx, mask, and matchingWord
final int bitIndex = mustWhoSite * chunkSize;
wordIdx = bitIndex >> 6;
final int up = bitIndex & 63;
mask = ((0x1L << chunkSize) - 1) << up;
matchingWord = (((long)mustWhoValue) << up);
this.site = mustWhoSite;
this.value = mustWhoValue;
}
//-------------------------------------------------------------------------
@Override
public boolean matches(final State state)
{
assert
(
state.containerStates()[0].matchesWhoVertex(wordIdx, mask, matchingWord)
==
(state.containerStates()[0].whoVertex(site) == value)
);
return state.containerStates()[0].matchesWhoVertex(wordIdx, mask, matchingWord);
}
@Override
public boolean onlyRequiresSingleMustEmpty()
{
return false;
}
@Override
public boolean onlyRequiresSingleMustWho()
{
return true;
}
@Override
public boolean onlyRequiresSingleMustWhat()
{
return false;
}
@Override
public SiteType graphElementType()
{
return SiteType.Vertex;
}
@Override
public void addMaskTo(final ChunkSet chunkSet)
{
chunkSet.addMask(wordIdx, mask);
}
@Override
public StateVectorTypes stateVectorType()
{
return StateVectorTypes.Who;
}
@Override
public int testedSite()
{
return site;
}
@Override
public int value()
{
return value;
}
@Override
public boolean negated()
{
return false;
}
//-------------------------------------------------------------------------
@Override
public boolean provesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (!other.negated() && value() == other.value());
// We prove not-what for any piece not owned by player, and also prove what if this player only owns a single piece type
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return (game.equipment().components()[other.value()].owner() != value());
else
return AtomicProposition.playerOnlyOwns(game, value(), other.value());
}
// True means we DO contain a specific player, so we prove not empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && other.negated());
}
@Override
public boolean disprovesIfTrue(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// True means we DO contain player we look for
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && value() == other.value());
// We disprove what for any piece not owned by player, and also disprove not-what for piece if player only owns a single piece type
if (other.stateVectorType() == StateVectorTypes.What)
{
if (other.negated())
return AtomicProposition.playerOnlyOwns(game, value(), other.value());
else
return (game.equipment().components()[other.value()].owner() != value());
}
// True means we DO contain a specific player, so we disprove empty
return (value() > 0 && other.stateVectorType() == StateVectorTypes.Empty && !other.negated());
}
@Override
public boolean provesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// We prove not-who
if (other.stateVectorType() == StateVectorTypes.Who)
return (other.negated() && other.value() == value());
// We prove not-what for any what owned by this player
if (other.stateVectorType() == StateVectorTypes.What && other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
@Override
public boolean disprovesIfFalse(final AtomicProposition other, final Game game)
{
if (graphElementType() != other.graphElementType())
return false;
if (testedSite() != other.testedSite())
return false;
// We disprove what for any what owned by this player
if (other.stateVectorType() == StateVectorTypes.What && !other.negated())
return (AtomicProposition.ownedComponentIDs(game, value()).contains(other.value()));
return false;
}
//-------------------------------------------------------------------------
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + (int) (mask ^ (mask >>> 32));
result = prime * result + (int) (matchingWord ^ (matchingWord >>> 32));
result = prime * result + wordIdx;
return result;
}
@Override
public boolean equals(final Object obj)
{
if (this == obj)
return true;
if (!(obj instanceof SingleMustWhoVertex))
return false;
final SingleMustWhoVertex other = (SingleMustWhoVertex) obj;
return (mask == other.mask && matchingWord == other.matchingWord && wordIdx == other.wordIdx);
}
@Override
public String toString()
{
return "[Vertex " + site + " must be owned by Player " + value + "]";
}
//-------------------------------------------------------------------------
}
| 6,433 | 24.839357 | 133 |
java
|
Ludii
|
Ludii-master/Generation/src/approaches/random/Generator.java
|
package approaches.random;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import compiler.Compiler;
import game.Game;
import grammar.Grammar;
import main.FileHandling;
import main.StringRoutines;
import main.grammar.Baptist;
import main.grammar.Description;
import main.grammar.Report;
import main.grammar.ebnf.EBNF;
import main.grammar.ebnf.EBNFClause;
import main.grammar.ebnf.EBNFClauseArg;
import main.grammar.ebnf.EBNFRule;
import main.options.UserSelections;
import other.context.Context;
import other.move.Move;
import other.trial.Trial;
import parser.Expander;
import parser.Parser;
//-----------------------------------------------------------------------------
/**
* Random ludeme generator.
*
* @author cambolbro
*/
public class Generator
{
/**
* First item in each entry is the relevant ludeme name, the second item
* is the list of strings that can be used in it wherever a <string>
* parameter is expected. Repeat strings that you want to occur more often.
*/
private final static String[][][] stringPool =
{
// Player
{
{ // Ludemes:
"player",
},
{ // Strings:
"A", "A", "A", "A", "B", "B", "B", "B", "C", "C", "D",
}
},
// Piece
{
{ // Ludemes:
"piece", "hop", "slide", "fromTo", "place", "leap", "step",
"shoot", "promotion", "count",
},
{ // Strings:
"Disc", "Disc", "Disc", "Disc", "Disc0", "Disc0", "Disc1", "Disc1",
"Disc2", "Disc2", "Disc3", "Disc3", "Disc4", "Disc4", "Disc5", "Disc6",
"DiscA", "DiscB", "DiscA1", "DiscB1", "DiscA2", "DiscB2",
"Pawn", "Pawn", "Pawn0", "Pawn1", "Pawn2", "Pawn3", "Pawn4",
"King", "King0", "King1", "King2", "King3",
}
},
// Region
{
{ // Ludemes:
"regions", "region", "sites",
},
{ // Strings:
"Region", "Region0", "Region1", "Region2", "Region3", "Region4",
}
},
// Track
{
{ // Ludemes:
"track",
},
{ // Strings:
"Track", "Track0", "Track1", "Track2", "Track3", "Track4",
}
},
// Vote
{
{ // Ludemes:
"vote",
},
{ // Strings:
"Yes", "No", "Maybe",
}
},
// Propose
{
{ // Ludemes:
"propose",
},
{ // Strings:
"Win", "Draw", "Loss", "Tie", "Pass",
}
},
// Hints
{
{ // Ludemes:
"hints",
},
{ // Strings:
"Hints", "Hints0", "Hints1", "Hints2", "Hints3",
}
},
};
/** Maximum search depth. */
private final static int MAX_DEPTH = 100;
/** Point at which to stop random playouts. */
private final static int MAX_MOVES = 2000;
/** Maximum length for generated arrays. */
private final static int MAX_ARRAY_LENGTH = 10;
//-------------------------------------------------------------------------
/**
* @param ruleName Rule name.
* @param seed RNG seed.
* @return Ludemeplex description generated by completing this rule.
*/
public static String generate(final String ruleName, final long seed)
{
final Random rng = new Random(seed);
rng.nextInt(); // Burn first value, or will always get the same first
// nextInt(R) if the bound is small and a power of 2.
final List<EBNFRule> rules = findRules(ruleName);
if (rules.isEmpty())
{
System.out.println("** Rule " + ruleName + " could not be found.");
return null;
}
// System.out.println("Rules:");
// for (final EBNFRule rule : rules)
// System.out.println("- " + rule);
String ludeme = complete(rules.get(rng.nextInt(rules.size())), rng, 0);
ludeme = instantiatePrimitives(ludeme, rng);
// Format nicely
final Report report = new Report();
final Description description = new Description(ludeme);
Expander.expand(description, new UserSelections(new ArrayList<String>()), report, false);
if (report.isError())
return ludeme;
return description.expanded();
}
//-------------------------------------------------------------------------
/**
* @return Returns list of rules that match a given name.
*/
static List<EBNFRule> findRules(final String ruleName)
{
final List<EBNFRule> list = new ArrayList<EBNFRule>();
final EBNF ebnf = Grammar.grammar().ebnf();
String str = StringRoutines.toDromedaryCase(ruleName);
// Try exact match
EBNFRule rule = ebnf.rules().get(str);
if (rule != null)
{
list.add(rule);
return list;
}
// Try match with rule delimiters '<...>'
rule = ebnf.rules().get("<" + str + ">");
if (rule != null)
{
list.add(rule);
return list;
}
// Find any match
if (str.charAt(0) == '<')
str = str.substring(1);
if (str.charAt(str.length() - 1) == '>')
str = str.substring(0, str.length() - 1);
for (final EBNFRule ruleN : ebnf.rules().values())
{
String strN = ruleN.lhs();
if (strN.charAt(0) == '<')
strN = strN.substring(1);
if (strN.charAt(strN.length() - 1) == '>')
strN = strN.substring(0, strN.length() - 1);
while (strN.contains("."))
{
final int c = strN.indexOf(".");
strN = strN.substring(c + 1);
}
if (strN.equalsIgnoreCase(str))
list.add(ruleN);
}
return list;
}
//-------------------------------------------------------------------------
/**
* @return Complete ludemeplex string from a given rule.
*/
private static String complete(final EBNFRule rule, final Random rng, final int depth)
{
//System.out.println("\nCompleting: " + rule.lhs());
if (depth > MAX_DEPTH)
{
System.out.println("** Maximum depth " + MAX_DEPTH + " exceeded in complete() A.");
return "";
}
// Check for quick exit to limit recursion depth
if (rule.lhs().equals("<int>"))
{
if (rng.nextInt(2 + depth) != 0)
{
// Stop recursion and return terminal version
return "%int%";
}
}
else if (rule.lhs().equals("<boolean>"))
{
if (rng.nextInt(2 + depth) != 0)
{
// Stop recursion and return terminal version
return (rng.nextInt(2) != 0) ? "True" : "False";
}
}
else if (rule.lhs().equals("<float>"))
{
if (rng.nextInt(2 + depth) != 0)
{
// Stop recursion and return terminal version
return "%float%";
}
}
else if (rule.lhs().equals("<dim>"))
{
// **
// ** Note: Limit dim recursion or (board ...) ludemes are never completed!
// **
if (rng.nextInt(2 + depth) != 0)
{
// Stop recursion and return terminal version
return "%dim%";
}
}
if (rule.rhs() == null || rule.rhs().isEmpty())
{
System.out.println("** Rule has no clauses: " + rule);
return "";
}
// We must sort the clauses to ensure that multiple iterations, with the same rng seed, produce the same output
final List<EBNFClause> clauses = new ArrayList<>(rule.rhs());
Collections.sort(clauses, Comparator.comparing(EBNFClause::toString));
final EBNFClause clause = clauses.get(rng.nextInt(rule.rhs().size()));
// System.out.println("clause: " + clause + " " + (clause.isTerminal() ? "T" : "") + (clause.isRule() ? "R" : "") + (clause.isConstructor() ? "C" : ""));
if (clause.isTerminal())
{
final String clauseString = clause.toString();
if (clauseString.equals("string"))
{
return "%string%";
}
// Check for primitive arrays.
// NOTE: the length of the arrays is biased towards small lengths since rng.nextInt() is re-evaluated at every iteration.
else if (clauseString.equals("{<int>}"))
{
StringBuilder sb = new StringBuilder();
sb.append('{');
for (int i = 0; i < rng.nextInt(MAX_ARRAY_LENGTH - 1) + 1; i++)
{
sb.append("%int% ");
}
sb.append('}');
return sb.toString();
}
else if (clauseString.equals("{<float>}"))
{
StringBuilder sb = new StringBuilder();
sb.append('{');
for (int i = 0; i < rng.nextInt(MAX_ARRAY_LENGTH - 1) + 1; i++)
{
sb.append("%float% ");
}
sb.append('}');
return sb.toString();
}
else if (clauseString.equals("{<boolean>}"))
{
StringBuilder sb = new StringBuilder();
sb.append('{');
for (int i = 0; i < rng.nextInt(MAX_ARRAY_LENGTH - 1) + 1; i++)
{
sb.append((rng.nextInt(2) != 0) ? "True " : "False ");
}
sb.append('}');
return sb.toString();
}
else if (clauseString.equals("{<dim>}"))
{
StringBuilder sb = new StringBuilder();
sb.append('{');
for (int i = 0; i < rng.nextInt(MAX_ARRAY_LENGTH - 1) + 1; i++)
{
sb.append("%dim% ");
}
sb.append('}');
return sb.toString();
}
// Return complete clause immediately
return clauseString;
}
if (clause.isRule())
{
final List<EBNFRule> clauseRule = findRules(clause.token());
if (clauseRule.isEmpty())
{
System.out.println("** Clause has no rule match: " + clause.token());
return "?";
}
else if (clauseRule.size() > 1)
{
System.out.println("** Clause has more than one rule match: " + clause.token());
return "?";
}
if (depth + 1 >= MAX_DEPTH)
{
//System.out.println("** Maximum depth " + MAX_DEPTH + " reached in complete() B.");
return "";
}
return complete(clauseRule.get(rng.nextInt(clauseRule.size())), rng, depth + 1);
}
// Clause must be a constructor at this point
return handleConstructor(clause, rng, depth);
}
//-------------------------------------------------------------------------
static String handleConstructor(final EBNFClause clause, final Random rng, final int depth)
{
//System.out.println(depth);
if (depth > MAX_DEPTH)
{
System.out.println("** Maximum depth " + MAX_DEPTH + " exceeded in handleConstructor(). A");
return "";
}
String str = "(" + clause.token();
// Determine 'or' groups
final int MAX_OR_GROUPS = 10;
final BitSet[] orGroups = new BitSet[MAX_OR_GROUPS];
for (int n = 0; n < MAX_OR_GROUPS; n++)
orGroups[n] = new BitSet();
for (int a = 0; a < clause.args().size(); a++)
{
final EBNFClauseArg arg = clause.args().get(a);
orGroups[arg.orGroup()].set(a);
}
for (int n = 1; n < MAX_OR_GROUPS; n++)
while (orGroups[n].cardinality() > 1)
orGroups[n].set(rng.nextInt(clause.args().size()), false);
// Determine which args to use
final BitSet use = new BitSet();
for (int a = 0; a < clause.args().size(); a++)
for (int n = 0; n < MAX_OR_GROUPS; n++)
if (orGroups[n].get(a))
use.set(a);
// Turn off some optional arguments (the deeper, the more likely)
for (int a = 0; a < clause.args().size(); a++)
if (clause.args().get(a).isOptional() && rng.nextInt(2 + depth) != 0)
use.set(a, false);
for (int a = 0; a < clause.args().size(); a++)
{
final EBNFClauseArg arg = clause.args().get(a);
if (!use.get(a))
continue; // skip this arg
if (arg.parameterName() == null)
str += " ";
else
str += " " + arg.parameterName() + ":";
if (arg.nesting() == 0)
{
// Not an array
final String argStr = handleArg(arg, rng, depth);
if (argStr == "")
return ""; // maximum depth reached
str += argStr;
}
else
{
// Handle array (might have nested sub-arrays)
str += "{";
final int numItems = 1 + lowBiasedRandomInteger(rng, false) % 4;
for (int i = 0; i < numItems; i++)
{
if (arg.nesting() == 1)
{
// Single array
final String argStr = handleArg(arg, rng, depth);
if (argStr == "")
return ""; // maximum depth reached
str += " " + argStr;
}
else if (arg.nesting() == 2)
{
// Nested sub-arrays
str += " {";
final int numSubItems = 1 + lowBiasedRandomInteger(rng, false) % 4;
for (int j = 0; j < numSubItems; j++)
{
final String argStr = handleArg(arg, rng, depth);
if (argStr == "")
return ""; // maximum depth reached
str += " " + argStr;
}
str += " }";
}
else
{
//System.out.println("** Generator.handleConstructor(): Three dimensional arrays not support yet.");
}
}
str += " }";
}
}
str += ")";
return str;
}
static String handleArg(final EBNFClauseArg arg, final Random rng, final int depth)
{
if (depth > MAX_DEPTH)
{
System.out.println("** Maximum depth " + MAX_DEPTH + " exceeded in handleArg() A.");
return "";
}
if (EBNF.isTerminal(arg.token()))
{
// Simply instantiate here rather than recursing, to catch 'string'
// (also catches 'int', 'boolean' and 'float).
return arg.token(); //toString();
}
final List<EBNFRule> argRule = findRules(arg.token());
if (argRule.isEmpty())
{
System.out.println("** Clause arg has no rule match: " + arg.token());
return "?";
}
else if (argRule.size() > 1)
{
System.out.println("** Clause arg has more than one rule match: " + arg.token());
return "?";
}
if (depth + 1 >= 1000)
{
System.out.println("** Safe generation depth " + depth + " exceeded in handleArg() B.");
return "";
}
return complete(argRule.get(0), rng, depth + 1);
}
//-------------------------------------------------------------------------
static String instantiatePrimitives(final String input, final Random rng)
{
String str = instantiateStrings(input.trim(), rng);
str = instantiateIntegers(str, rng);
str = instantiateFloats(str, rng);
str = instantiateDims(str, rng);
return str;
}
static String instantiateStrings(final String input, final Random rng)
{
String str = input.trim();
// Instantiate 'string' placeholders
int c = 0;
while (true)
{
// Find next occurrence of 'string'
c = str.indexOf("%string%", c + 1);
if (c < 0)
break;
final String owner = enclosingLudemeName(str, c);
//System.out.println("owner='" + owner + "'");
String replacement = null;
if
(
owner.equalsIgnoreCase("game")
||
owner.equalsIgnoreCase("match")
||
owner.equalsIgnoreCase("subgame")
)
{
// Create a name for this game
replacement = Baptist.baptist().name(str.hashCode(), 4);
}
if (replacement == null)
{
// Look for a ludeme from the stringPool
for (int group = 0; group < stringPool.length && replacement == null; group++)
for (int n = 0; n < stringPool[group][0].length && replacement == null; n++)
if (owner.equalsIgnoreCase(stringPool[group][0][n]))
replacement = stringPool[group][1][rng.nextInt(stringPool[group][1].length)];
}
if (replacement == null)
{
// Create random coordinate
replacement = (char)('A' + rng.nextInt(26)) + ("" + rng.nextInt(26));
}
str = str.substring(0, c) + "\"" + replacement + "\"" + str.substring(c + "%string%".length());
}
return str;
}
static String instantiateIntegers(final String input, final Random rng)
{
String str = input.trim();
// Instantiate 'int' placeholders
int c = 0;
while (true)
{
// Find next occurrence of 'int'
c = str.indexOf("%int%", c + 1);
if (c < 0)
break;
int num = lowBiasedRandomInteger(rng, true);
final String owner = enclosingLudemeName(str, c);
if (owner.equalsIgnoreCase("players") && rng.nextInt(4) != 0)
{
// Restrict number of players
num = num % 4 + 1;
}
str = str.substring(0, c) + num + str.substring(c + "%int%".length());
}
return str;
}
static String instantiateDims(final String input, final Random rng)
{
String str = input.trim();
// Instantiate 'dim' placeholders
int c = 0;
while (true)
{
// Find next occurrence of 'dim'
c = str.indexOf("%dim%", c + 1);
if (c < 0)
break;
// Positive number within reasonable bounds
int num = Math.abs(lowBiasedRandomInteger(rng, true)) % 20;
final String owner = enclosingLudemeName(str, c);
if (owner.equalsIgnoreCase("players") && rng.nextInt(4) != 0)
{
// Restrict number of players
num = num % 4 + 1;
}
str = str.substring(0, c) + num + str.substring(c + "%dim%".length());
}
return str;
}
static String instantiateFloats(final String input, final Random rng)
{
String str = input.trim();
final DecimalFormat df = new DecimalFormat("#.##");
// Instantiate 'float' placeholders
int c = 0;
while (true)
{
// Find next occurrence of 'float'
c = str.indexOf("%float%", c + 1);
if (c < 0)
break;
final double num = lowBiasedRandomInteger(rng, true) / 4.0;
str = str.substring(0, c) + df.format(num).replace(',', '.') + str.substring(c + "%float%".length());
}
return str;
}
//-------------------------------------------------------------------------
/**
* @return Name of enclosing ludeme (if any).
*/
static String enclosingLudemeName(final String str, final int fromIndex)
{
int c = fromIndex;
while (c >= 0 && str.charAt(c) != '(')
c--;
if (c < 0)
return str.split(" ")[0];
int cc = c + 1;
while (cc < str.length() && str.charAt(cc) != ' ')
cc++;
return str.substring(c + 1, cc);
}
//-------------------------------------------------------------------------
/**
* @return Random number (biased towards lower values) that is sometimes negative.
*/
private static int lowBiasedRandomInteger(final Random rng, final boolean negate)
{
int r = 0;
switch (rng.nextInt(10))
{
case 0: r = rng.nextInt(2) + 1; break;
case 1: r = rng.nextInt(4); break;
case 2: r = rng.nextInt(3) + 1; break;
case 3: r = rng.nextInt(4) + 1; break;
case 4: r = rng.nextInt(5) + 1; break;
case 5: r = rng.nextInt(6) + 1; break;
case 6: r = rng.nextInt(8); break;
case 7: r = rng.nextInt(16); break;
case 8: r = rng.nextInt(100); break;
case 9: r = rng.nextInt(1000); break;
default: r = 0;
}
if (negate && rng.nextInt(20) == 0)
r = -r;
return r;
}
//-------------------------------------------------------------------------
/**
* @param numGames The number of games to generate.
* @param randomSeed If the seed should be randomised.
* @param isValid Only the games with all the requirement and not satisfying the WillCrash test.
* @param boardlessIncluded If we try to generate some boardless games.
* @param doSave Whether to save generated games.
* @return The last valid game description.
*/
public static String testGames
(
final int numGames, final boolean randomSeed,
final boolean isValid, final boolean boardlessIncluded, final boolean doSave
)
{
Grammar.grammar().ebnf(); // trigger grammar and EBNF structure to be created
// final EBNF ebnf = Grammar.grammar().ebnf();
// for (final EBNFRule rule : ebnf.rules().values())
// System.out.println(rule);
final long startAt = System.currentTimeMillis();
int numValid = 0;
int numParse = 0;
int numCompile = 0;
int numFunctional = 0;
int numPlayable = 0;
// Keep a record of the last valid, playable, generated game, which will be returned at the end.
String lastGeneratedGame = null;
final Random rng = new Random();
// Generate games
for (int n = 0; n < numGames; n++)
{
System.out.println("\n---------------------------------\nGame " + n + ":");
final String str = Generator.generate("game", randomSeed ? rng.nextLong() : n);
System.out.println(str);
if (str == "")
continue; // generation failed
numValid++;
String gameName = StringRoutines.gameName(str);
if (gameName == null)
gameName = "Anon";
final String fileName = gameName + ".lud"; // just in case...
// Check whether game parses
final Description description = new Description(str);
final UserSelections userSelections = new UserSelections(new ArrayList<String>());
final Report report = new Report();
Parser.expandAndParse(description, userSelections, report, true, false);
if (report.isError())
{
// Game does not parse
if (doSave)
FileHandling.saveStringToFile(str, "../Common/res/lud/test/buggy/unparsable/", fileName);
continue;
}
//System.out.println("Parses...");
numParse++;
if (!boardlessIncluded)
{
//if (game.isBoardless())
if (description.expanded().contains("boardless"))
continue;
}
for (final String warning : report.warnings())
if (!warning.contains("No version info."))
System.out.println("- Warning: " + warning);
// Check whether game compiles
Game game = null;
try
{
game = (Game)Compiler.compileTest(new Description(str), false);
}
catch (final Exception e)
{
for (final String error : report.errors())
System.out.println("- Error: " + error);
for (final String warning : report.warnings())
if (!warning.contains("No version info."))
System.out.println("- Warning: " + warning);
e.printStackTrace();
}
if (game == null)
{
// Game does not compile
if (doSave)
FileHandling.saveStringToFile(str, "../Common/res/lud/test/buggy/uncompilable/", fileName);
continue;
}
//System.out.println("Compiles...");
numCompile++;
if (isValid)
{
if (game.hasMissingRequirement() || game.willCrash())
continue;
System.out.println("Not known to crash...");
}
// if (!boardlessIncluded)
// {
// //if (game.isBoardless())
// if (description.expanded().contains("boardless"))
// continue;
// System.out.println("Parses...");
// }
// Check whether game is functional
try
{
if (!isFunctional(game))
{
// Game is not functional
if (doSave)
FileHandling.saveStringToFile(str, "../Common/res/lud/test/buggy/nonfunctional/", fileName);
continue;
}
}
catch (final Exception e)
{
System.out.println("Handling exception during playability test.");
e.printStackTrace();
}
//System.out.println("Is functional...");
numFunctional++;
// Check whether game is playable
if (!isPlayable(game))
{
// Game is not playable
if (doSave)
FileHandling.saveStringToFile(str, "../Common/res/lud/test/buggy/unplayable/", fileName);
continue;
}
System.out.println("Is playable.");
numPlayable++;
//if (doSave)
FileHandling.saveStringToFile(str, "../Common/res/lud/test/playable/", fileName);
lastGeneratedGame = str;
}
final double secs = (System.currentTimeMillis() - startAt) / 1000.0;
System.out.println
(
"\n===========================================\n"
+
numGames + " random games generated in " + secs + "s:\n"
+
numValid + " valid (" + (numValid * 100.0 / numGames) + "%).\n"
+
numParse + " parse (" + (numParse * 100.0 / numGames) + "%).\n"
+
numCompile + " compile (" + (numCompile * 100.0 / numGames) + "%).\n"
+
numFunctional + " functional (" + (numFunctional * 100.0 / numGames) + "%).\n"
+
numPlayable + " playable (" + (numPlayable * 100.0 / numGames) + "%).\n"
);
return lastGeneratedGame;
}
//-------------------------------------------------------------------------
/**
* Method from Eric to improve some generations did with Ludii.
*
* @param numGames The number of games to generate.
* @param dlpRestriction If we apply some DLP restrictions (like no
* boardless, cards etc...)
* @param withDecision If we keep the games with only decision moves.
* @return The last valid game description.
*/
public static String testGamesEric
(
final int numGames, final boolean dlpRestriction,
final boolean withDecision
)
{
Grammar.grammar().ebnf(); // trigger grammar and EBNF structure to be created
final long startAt = System.currentTimeMillis();
final Report report = new Report();
// Keep a record of the last valid, playable, generated game, which will be returned at the end.
String lastGeneratedGame = null;
final Random rng = new Random();
// Generate games
int n = 0;
int numTry = 0;
while (n < numGames)
{
final String str = Generator.generate("game", rng.nextLong());
if (str == "")
{
numTry++;
// System.out.println("Generation failed for try " + numTry);
continue; // generation failed
}
final boolean containsPlayRules = str.contains("(play");
final boolean containsEndRules = str.contains("(end");
final boolean containsMatch = str.contains("(match");
if (!containsPlayRules || !containsEndRules || containsMatch)
{
numTry++;
// System.out.println("Game is a match or does not generate a play and end rule
// " + numTry);
continue;
}
// Check whether game parses
final Description description = new Description(str);
final UserSelections userSelections = new UserSelections(new ArrayList<String>());
Parser.expandAndParse(description, userSelections, report, true, false);
if (report.isError())
{
// Game does not parse
// FileHandling.saveStringToFile(str,
// "../Common/res/lud/test/buggy/unparsable/", fileName);
numTry++;
// System.out.println("Game unparsable for try " + numTry);
continue;
}
// for (final String warning : report.warnings())
// if (!warning.contains("No version info."))
// System.out.println("- Warning: " + warning);
// Check whether game compiles
Game game = null;
try
{
game = (Game)Compiler.compileTest(new Description(str), false);
}
catch (final Exception e)
{
// Nothing to do.
}
if (game == null)
{
// Game does not compile
numTry++;
// System.out.println("Game uncompilable for try " + numTry);
continue;
}
if (game.hasMissingRequirement() || game.willCrash())
{
numTry++;
// System.out.println("Game with warning and possible crash for try " + numTry);
continue;
}
// No boardless, No match, no deduc Puzzle, cards, dominoes or large pieces, no
// hidden info.
// Only Alternating game.
if (dlpRestriction)
if (game.hasSubgames() || game.isBoardless() || game.isDeductionPuzzle() || game.hasCard()
|| game.hasDominoes() || game.hasLargePiece() || !game.isAlternatingMoveGame()
|| game.hiddenInformation()
)
{
numTry++;
// System.out.println("Game not satisfying for try " + numTry);
continue;
}
final String fileName = game.name() + ".lud";
// Check whether game is functional
if (withDecision)
{
if (!isFunctionalAndWithOnlyDecision(game))
{
// Game is not functional
numTry++;
// System.out.println("Game non functional or has a move with no decision for
// try " + numTry);
continue;
}
}
else if (!isFunctional(game))
{
// Game is not functional
numTry++;
FileHandling.saveStringToFile(str, "../Common/res/lud/test/buggy/nonfunctional/", fileName);
// System.out.println("Game non functional for
// try " + numTry);
continue;
}
// Check whether game is playable
if (!isPlayable(game))
{
// Game is not playable
numTry++;
FileHandling.saveStringToFile(str, "../Common/res/lud/test/buggy/unplayable/", fileName);
// System.out.println("Game unplayable for try " + numTry);
continue;
}
else
{
FileHandling.saveStringToFile(str, "../Common/res/lud/test/buggy/toTest/", fileName);
System.out.println("GAME " + n + " GENERATED");
numTry++;
n++;
}
lastGeneratedGame = str;
}
final double secs = (System.currentTimeMillis() - startAt) / 1000.0;
System.out.println("Generation done in " + secs + " seconds");
System.out.println(numTry + " tries were necessary.");
return lastGeneratedGame;
}
/**
* @return Whether a trial of the game can be played without crashing.
*/
public static boolean isFunctionalAndWithOnlyDecision(final Game game)
{
final Context context = new Context(game, new Trial(game));
game.start(context);
Trial trial = null;
try
{
trial = game.playout
(
context, null, 1.0, null, 0, MAX_MOVES,
ThreadLocalRandom.current()
);
}
catch(final Exception e)
{
e.printStackTrace();
}
if(trial == null)
return false;
for(final Move m : trial.generateCompleteMovesList())
if(!m.isDecision())
return false;
return true;
}
//-------------------------------------------------------------------------
/**
* @return Whether a trial of the game can be played without crashing.
*/
public static boolean isFunctional(final Game game)
{
final Context context = new Context(game, new Trial(game));
game.start(context);
Trial trial = null;
try
{
trial = game.playout
(
context, null, 1.0, null, 0, MAX_MOVES,
ThreadLocalRandom.current()
);
}
catch(final Exception e)
{
e.printStackTrace();
}
return trial != null;
}
//-------------------------------------------------------------------------
/**
* @return Whether the game is basically playable, i.e. more trials are of
* reasonable length than not. A trial is of reasonable length if it
* lasts at least 2 * num_players moves and ends before 90% of MAX_MOVES are reached.
*/
public static boolean isPlayable(final Game game)
{
final Context context = new Context(game, new Trial(game));
final int NUM_TRIALS = 10;
int numResults = 0;
for (int t = 0; t < NUM_TRIALS; t++)
{
game.start(context);
Trial trial = null;
try
{
trial = game.playout
(
context, null, 1.0, null, 0, MAX_MOVES,
ThreadLocalRandom.current()
);
}
catch(final Exception e)
{
e.printStackTrace();
}
//System.out.println(trial.numMoves() + " moves in " + trial.numberOfTurns() + " turns.");
if (trial == null)
return false;
final int minMoves = 2 * game.players().count();
final int maxMoves = MAX_MOVES * 9 / 10;
if (trial.numMoves() >= minMoves && trial.numMoves() <= maxMoves)
numResults++;
}
return numResults >= NUM_TRIALS / 2;
}
//-------------------------------------------------------------------------
@SuppressWarnings("static-method")
void test()
{
Grammar.grammar().ebnf(); // trigger grammar and EBNF structure to be created
// Check rules
int numClauses = 0;
for (final EBNFRule rule : Grammar.grammar().ebnf().rules().values())
{
numClauses += rule.rhs().size();
for (final EBNFClause clause : rule.rhs())
{
//System.out.println("EBNF clause: " + clause);
if (clause != null && clause.args() != null)
for (final EBNFClauseArg arg : clause.args())
{
final List<EBNFRule> list = findRules(arg.token());
if
(
list.isEmpty()
&&
!arg.token().equalsIgnoreCase("string")
&&
!Character.isUpperCase(arg.token().charAt(0)) // probably a single enum that has been instantiated
)
{
System.out.println("** No rule for: " + arg);
}
}
}
}
System.out.println(Grammar.grammar().ebnf().rules().size() + " EBNF rules with " + numClauses + " clauses generated.");
// final Random rng = new Random();
// final int bound = 2;
// for (int seed = 0; seed < 100; seed++)
// {
// rng.setSeed(seed);
// //rng.nextInt();
// for (int n = 0; n < 32; n++)
// System.out.print(rng.nextInt(bound) + " ");
// System.out.println();
// }
System.out.println("===========================================================\n");
final long startAt = System.currentTimeMillis();
// Generate games
final int NUM_GAMES = 1000;
for (int n = 0; n < NUM_GAMES; n++)
{
final String str = generate("game", n);
if (n % 100 == 0)
{
System.out.println(n + ":");
System.out.println(str == "" ? "** Generation failed.\n" : str);
}
}
final double secs = (System.currentTimeMillis() - startAt) / 1000.0;
System.out.println(NUM_GAMES + " games generated in " + secs + "s.");
System.out.println("===========================================================\n");
// Generate sub-ludeme
String str = generate("or", 0);
System.out.println(str);
str = generate("or", 1);
System.out.println(str);
System.out.println("===========================================================\n");
// Generate sub-ludeme
str = generate("board", System.currentTimeMillis());
System.out.println(str);
System.out.println("===========================================================\n");
// Generate enum
str = generate("ShapeType", 0);
System.out.println(str);
str = generate("ShapeType", 1);
System.out.println(str);
}
//-------------------------------------------------------------------------
/**
* The main method of the generator.
*
* @param arg
*/
public static void main(final String[] arg)
{
final Generator generator = new Generator();
generator.test();
}
}
| 33,092 | 24.996072 | 156 |
java
|
Ludii
|
Ludii-master/Generation/test/RandomGameTester.java
|
import approaches.random.Generator;
/**
* Random game tester.
* @author cambolbro
*/
public class RandomGameTester
{
public static void main(final String[] arg)
{
Generator.testGames(10, true, false, false, false);
}
}
| 228 | 15.357143 | 53 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/Arg.java
|
package compiler;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import annotations.Hide;
import grammar.Grammar;
import main.grammar.Call;
import main.grammar.Instance;
import main.grammar.Report;
import main.grammar.Token;
//-----------------------------------------------------------------------------
/**
* Constructor argument read in from file, in compilable format.
* Could be a constructor, terminal (String, enum, etc.) or list of constructors.
* @author cambolbro
*/
public abstract class Arg
{
// Name of the symbol
protected String symbolName = null;
// Optional parameter name
protected String parameterName = null;
// Possible instances of this symbol that might be instantiated
protected final List<Instance> instances = new ArrayList<Instance>();
//-------------------------------------------------------------------------
/**
* Constructor
*
* @param symbolName Symbol name.
* @param parameterName Optional parameter label.
*/
public Arg(final String symbolName, final String parameterName)
{
this.symbolName = (symbolName == null) ? null : new String(symbolName);
this.parameterName = (parameterName == null) ? null : new String(parameterName);
//System.out.println("+ Constructed symbolName \"" + this.symbolName + "\", label=\"" + this.label + "\".");
}
//-------------------------------------------------------------------------
/**
* @return The name of the symbol.
*/
public String symbolName()
{
return symbolName;
}
/**
* @return The name of the parameter.
*/
public String parameterName()
{
return parameterName;
}
/**
* @return The instances.
*/
public List<Instance> instances()
{
return Collections.unmodifiableList(instances);
}
//-------------------------------------------------------------------------
/**
* Factory method to generate appropriate subclass for this part.
*
* @param grammar The grammar.
* @param token The token.
* @return Appropriate Arg subclass for this part.
*/
public static Arg createFromToken(final Grammar grammar, final Token token)
{
Arg arg = null;
//System.out.println("+ Creating Arg for token: " + token);
switch (token.type())
{
case Terminal:
return new ArgTerminal(token.name(), token.parameterLabel());
case Class:
arg = new ArgClass(token.name(), token.parameterLabel());
for (final Token sub : token.arguments())
// ((ArgClass)arg).argsIn().add(createFromToken(grammar, sub));
((ArgClass)arg).add(createFromToken(grammar, sub));
break;
case Array:
arg = new ArgArray(token.name(), token.parameterLabel());
for (final Token sub : token.arguments())
// ((ArgArray)arg).elements().add(createFromToken(grammar, sub));
((ArgArray)arg).add(createFromToken(grammar, sub));
break;
default:
return null;
}
return arg;
}
//-------------------------------------------------------------------------
/**
* @param grammar The grammar.
* @param report The report.
* @return Whether was able to match all symbols in Arg tree.
*/
public abstract boolean matchSymbols(final Grammar grammar, final Report report);
/**
* @param expected Class type expected for this argument.
* @param depth Depth of recursive nesting (for formatting console display messages).
* @param report
* @param callNode Call node for this object's entry in the call tree.
* @param hasCompiled Record of whether items have compiled or not at least once in some context.
* @return The compiled object(s) based on this argument and its parameters, else null if none.
*/
public abstract Object compile
(
final Class<?> expected, final int depth, final Report report,
final Call callNode, final Map<String, Boolean> hasCompiled
);
//-------------------------------------------------------------------------
/**
* @param expected Expected class to check.
* @return Whether the expected class has a matching instance.
*/
public Instance matchingInstance(final Class<?> expected)
{
if (this instanceof ArgArray)
{
// Is an array
final List<Arg> elements = ((ArgArray)this).elements();
if (elements == null || elements.isEmpty())
return null;
if
(
elements.get(0) instanceof ArgArray
&&
((ArgArray)elements.get(0)).elements() != null
&&
!((ArgArray)elements.get(0)).elements().isEmpty()
&&
((ArgArray)elements.get(0)).elements().get(0) instanceof ArgArray
)
{
// Doubly nested array
final Class<?> componentType = expected.getComponentType().getComponentType().getComponentType();
if (componentType == null)
return null;
for (final Arg element : elements)
for (final Arg element2 : ((ArgArray)element).elements())
for (final Arg element3 : ((ArgArray)element2).elements())
for (final Instance instance : element3.instances())
{
final Class<?> elementType = instance.cls();
//System.out.println("+ ArgArray elementType is " + elementType + ", componentType is " + componentType);
if (!componentType.isAssignableFrom(elementType))
continue;
return instance;
}
}
else if (elements.get(0) instanceof ArgArray)
{
// Singly nested array
if (expected.getComponentType() == null)
return null;
final Class<?> componentType = expected.getComponentType().getComponentType();
if (componentType == null)
return null;
for (final Arg element : elements)
for (final Arg element2 : ((ArgArray)element).elements())
{
if (element2 == null)
continue;
for (final Instance instance : element2.instances())
{
final Class<?> elementType = instance.cls();
//System.out.println("+ ArgArray elementType is " + elementType + ", componentType is " + componentType);
if (!componentType.isAssignableFrom(elementType))
continue;
return instance;
}
}
}
else
{
// Flat array
final Class<?> componentType = expected.getComponentType();
if (componentType == null)
return null;
for (final Arg element : elements)
for (final Instance instance : element.instances())
{
final Class<?> elementType = instance.cls();
//System.out.println("+ ArgArray elementType is " + elementType + ", componentType is " + componentType);
if (!componentType.isAssignableFrom(elementType))
continue;
return instance;
}
}
}
else
{
// Check instances
for (int inst = 0; inst < instances.size(); inst++)
{
final Instance instance = instances.get(inst);
final Class<?> cls = instance.cls();
if (cls == null)
continue;
if (!expected.isAssignableFrom(cls))
continue;
if (cls.getAnnotation(Hide.class) != null)
continue;
return instance; // matching instance found
}
}
return null; // no matching instance
}
//-------------------------------------------------------------------------
}
| 7,178 | 27.042969 | 113 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/ArgArray.java
|
package compiler;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import compiler.exceptions.CompilerException;
import compiler.exceptions.UnknownArrayErrorException;
import grammar.Grammar;
import main.grammar.Call;
import main.grammar.Report;
import main.grammar.Call.CallType;
//-----------------------------------------------------------------------------
/**
* Argument in constructor consisting of a list of arguments (of the same type).
* @author cambolbro
*/
public class ArgArray extends Arg
{
/**
* Elements will probably be constructors,
* but could possibly be a nested array.
*/
private final List<Arg> elements = new ArrayList<Arg>();
//-------------------------------------------------------------------------
/**
* Constructor
*
* @param name The name of the argument.
* @param label the label of the argument.
*/
public ArgArray(final String name, final String label)
{
super(name, label);
}
//-------------------------------------------------------------------------
/**
* @return The elements.
*/
public List<Arg> elements()
{
return Collections.unmodifiableList(elements);
}
/**
* Add an element.
*
* @param arg The num element.
*/
public void add(final Arg arg)
{
elements.add(arg);
}
//-------------------------------------------------------------------------
@Override
public boolean matchSymbols(final Grammar grammar, final Report report)
{
for (final Arg arg : elements)
if (!arg.matchSymbols(grammar, report))
return false;
return true;
}
//-------------------------------------------------------------------------
@Override
public Object compile
(
final Class<?> expected, final int depth, final Report report,
final Call callNode, final Map<String, Boolean> hasCompiled
)
{
final String key = "Array of " + expected.getName();
if (!hasCompiled.containsKey(key))
hasCompiled.put(key, Boolean.FALSE);
String pre = "";
for (int n = 0; n < depth; n++)
pre += ". ";
pre += "[]: ";
// Create an empty array Call for this item
final Call call = (callNode == null) ? null : new Call(CallType.Array);
if (depth != -1)
{
//System.out.println("\n" + pre + "[][][][][][][][][][][][][][][][][][][][][][][][][][]");
//System.out.println(pre + "Compiling ArgArray (expected=" + expected.getName() + "):");
report.addLogLine("\n" + pre + "[][][][][][][][][][][][][][][][][][][][][][][][][][]");
report.addLogLine(pre + "Compiling ArgArray (expected=" + expected.getName() + "):");
}
final Class<?> elementType = expected.getComponentType();
if (depth != -1)
{
//System.out.println(pre + "Element type is: " + elementType);
report.addLogLine(pre + "Element type is: " + elementType);
}
if (elementType == null)
{
//throw new ArrayTypeNotFoundException(expected.getName());
return null;
}
// Create array of parameterised type.
// From: https://docs.oracle.com/javase/tutorial/reflect/special/arrayInstance.html
Object objs = null;
try
{
objs = Array.newInstance(elementType, elements.size());
for (int i = 0; i < elements.size(); i++)
{
final Arg elem = elements.get(i);
final Object match = elem.compile
(
elementType,
(depth == -1 ? -1 : depth+1),
report,
call,
hasCompiled
);
if (match == null)
{
// No match
return null;
}
Array.set(objs, i, match);
}
}
catch (final CompilerException e)
{
throw e;
}
catch(final Exception e)
{
e.printStackTrace();
throw new UnknownArrayErrorException(expected.getName(), e.getMessage());
}
final Object[] array = (Object[])objs;
if (depth != -1)
{
//System.out.println(pre + "+ Array okay, " + array.length + " elements matched.");
report.addLogLine(pre + "+ Array okay, " + array.length + " elements matched.");
}
if (callNode != null)
callNode.addArg(call);
hasCompiled.put(key, Boolean.TRUE);
return array;
//final List<Object> objects = new ArrayList<Object>();
//objects.add(array);
//return objects;
}
//-------------------------------------------------------------------------
@Override
public String toString()
{
String str = "";
str += "{ ";
for (int a = 0; a < elements.size(); a++)
{
final Arg arg = elements.get(a);
str += arg.toString() + " ";
}
str += "}";
return str;
}
//-------------------------------------------------------------------------
}
| 4,787 | 24.333333 | 93 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/ArgClass.java
|
package compiler;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import annotations.Hide;
import compiler.exceptions.BadKeywordException;
import compiler.exceptions.BadSymbolException;
import compiler.exceptions.BadSyntaxException;
import compiler.exceptions.ListNotSupportedException;
import grammar.Grammar;
import main.StringRoutines;
import main.grammar.Call;
import main.grammar.Call.CallType;
import main.grammar.Instance;
import main.grammar.Report;
import main.grammar.Symbol;
import main.grammar.Symbol.LudemeType;
//-----------------------------------------------------------------------------
/**
* Arg consisting of a class constructor and its arguments.
* @author cambolbro
*/
public class ArgClass extends Arg
{
/** List of input parameters for this ludeme class class constructor. */
private final List<Arg> argsIn = new ArrayList<Arg>();
//-------------------------------------------------------------------------
/**
* Constructor
* @param name Symbol name.
* @param label Optional parameter label.
*/
public ArgClass(final String name, final String label)
{
super(name, label);
}
//-------------------------------------------------------------------------
/**
* @return The list of arguments in it.
*/
public List<Arg> argsIn()
{
return Collections.unmodifiableList(argsIn);
}
/**
* Add an element.
*
* @param arg The new element.
*/
public void add(final Arg arg)
{
argsIn.add(arg);
}
//-------------------------------------------------------------------------
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean matchSymbols(final Grammar grammar, final Report report)
{
//System.out.println("At matchSymbols with symbolName: \"" + symbolName + "\".");
final char initial = symbolName.charAt(0);
if (Character.isAlphabetic(initial) && !Character.isLowerCase(initial))
throw new BadKeywordException(symbolName, "Class names should be lowercase.");
for (final Arg arg : argsIn)
arg.matchSymbols(grammar, report);
final String name = StringRoutines.upperCaseInitial(symbolName);
final List<Symbol> existing = grammar.symbolListFromClassName(name);
if (existing == null)
{
// System.out.println("** Symbol not found from \"" + keyword + "\" (original symbolName is \"" + symbolName + "\").");
// if (instances == null || instances.size() < 1)
// {
// System.out.println("** No instances!");
// }
// else
// {
// for (Instance instance : instances)
// System.out.println("** Instance is: " + instance.cls().getName());
// }
throw new BadKeywordException(name, null);
}
// Create list of instances
final List<Symbol> symbols = new ArrayList(existing);
instances.clear();
for (final Symbol symbol : symbols)
{
if (symbol == null)
throw new BadSymbolException(symbolName);
final Class<?> cls = loadClass(symbol);
if (cls == null)
{
// Probably tried to load class with same name as enum, ignore it.
// e.g. tried Mover() when it should be RoleType.Mover.
continue;
}
instances.add(new Instance(symbol, null)); //cls));
}
return true;
}
//-------------------------------------------------------------------------
/**
* Load class matching each symbol.
*/
private static Class<?> loadClass(final Symbol symbol)
{
Class<?> cls = null;
if (symbol.ludemeType() != LudemeType.Constant)
{
cls = symbol.cls();
}
// else
// {
// try { cls = Class.forName(symbol.path()); }
// catch (final ClassNotFoundException e)
// {
// // e.printStackTrace();
// }
// }
if (cls == null)
{
if (symbol.ludemeType() != LudemeType.Constant)
{
// If constant is enum, ignore class with same name
final Exception e = new Exception("Couldn't load ArgClass " + symbol.path() + ".");
e.printStackTrace();
// FIXME - should this be checked?
}
}
// else
// {
// System.out.println("cls : " + cls.getName() + "\nsymbol: " + symbol.path() + "\n");
// }
return cls;
}
//-------------------------------------------------------------------------
@Override
public Object compile
(
final Class<?> expected, final int depth, final Report report,
final Call callNode, final Map<String, Boolean> hasCompiled
)
{
String pre = "";
for (int n = 0; n < depth; n++)
pre += ". ";
pre += "C: ";
if (depth != -1)
{
report.addLogLine("\n" + pre + "==========================================");
report.addLogLine(pre + "Compiling ArgClass: " + this.symbolName);
report.addLogLine(pre + "\n" + pre + "Expected: name=" + expected.getName() + ", type=" + expected.getTypeName() + ".");
}
if (expected.getName().contains("[L"))
return null; // should not be handling arrays here
if (depth != -1)
{
report.addLogLine(pre + instances.size() + " instances:");
}
Call call = null;
for (int inst = 0; inst < instances.size(); inst++)
{
final Instance instance = instances.get(inst);
if (depth != -1)
{
report.addLogLine(pre + "-- instance " + inst + ": " + instance);
}
final Class<?> cls = instance.cls();
if (cls == null)
{
continue;
}
if (expected.isArray())
{
final Class<?> elementType = expected.getComponentType();
if (!elementType.isAssignableFrom(cls))
{
if (depth != -1)
{
report.addLogLine(pre + "Skipping non-assignable class " + cls.getName() + " (in array).");
}
continue;
}
}
else if (!expected.isAssignableFrom(cls))
{
if (depth != -1)
{
report.addLogLine(pre + "Skipping non-assignable class " + cls.getName() + ".");
}
continue;
}
if (cls.getAnnotation(Hide.class) != null)
{
// Do not compile hidden class
continue;
}
// Construct the object
Object object = null;
if (depth != -1)
{
report.addLogLine(pre + "\n" + pre + "Constructing: " + cls + "...");
}
// Ensure that an entry exist for this expected class (but beware that return type may be compiled instead).
final String key = expected.getName();
//System.out.println("AC key: " + key);
if (!hasCompiled.containsKey(key))
hasCompiled.put(key, Boolean.FALSE);
// We'll first try static construct() methods, and then constructors
for (final boolean tryConstructors : new boolean[] {false, true})
{
final List<Executable> executables = new ArrayList<Executable>();
if (tryConstructors)
{
// Get list of constructors
executables.addAll(Arrays.asList(cls.getDeclaredConstructors()));
}
else
{
// Get list of static construct() methods
final Method[] methods = cls.getDeclaredMethods();
for (final Method method : methods)
if (method.getName().equals("construct") && Modifier.isStatic(method.getModifiers()))
executables.add(method);
}
if (depth != -1)
{
report.addLogLine(pre + executables.size() + " constructors found.");
}
for (int c = 0; c < executables.size(); c++)
{
final Executable exec = executables.get(c);
if (depth != -1)
{
report.addLogLine(pre + "\n" + pre + "Constructor " + c + ": " + exec.toString());
}
if (exec.getAnnotation(Hide.class) != null)
{
// Do not compile hidden class
continue;
}
// Get argument types and annotations for this constructor's arguments
Parameter[] params = null;
Class<?>[] types = null;
Annotation[][] annos = null;
try
{
params = exec.getParameters();
types = exec.getParameterTypes();
annos = exec.getParameterAnnotations();
}
catch (final IllegalArgumentException e)
{
e.printStackTrace();
}
final int numSlots = params.length;
if (numSlots < argsIn.size())
{
if (depth != -1)
report.addLogLine(pre + "Not enough args in constructor for " + argsIn.size() + " input args.");
continue;
}
if (numSlots == 0)
{
// No arguments to match
try
{
if (tryConstructors)
object = ((Constructor<?>)exec).newInstance();
else
object = ((Method)exec).invoke(null, new Object[0]);
}
catch (final Exception e)
{
// Failed to compile.
if (depth != -1)
{
report.addLogLine(pre + "*********************");
report.addLogLine(pre + "Failed to create new instance (no args).");
report.addLogLine(pre + "*********************\n");
}
e.printStackTrace();
}
if (object != null)
{
// Success!
call = new Call(CallType.Class, instance, expected);
if (callNode != null)
callNode.addArg(call);
break; // success!
}
}
// Try to match arguments for this constructor
// Get optional and named args based on annotations
final String[] name = new String[numSlots];
int numOptional = 0;
final BitSet isOptional = new BitSet();
for (int a = 0; a < numSlots; a++)
{
name[a] = null; // just to be sure!
if (depth != -1)
{
report.addLog(pre + "- con arg " + a + ": " + types[a].getName());
}
if (types[a].getName().equals("java.util.List"))
throw new ListNotSupportedException();
for (int b = 0; b < annos[a].length; b++)
{
if
(
annos[a][b].toString().equals("@annotations.Opt()")
||
annos[a][b].toString().equals("@annotations.Or()")
||
annos[a][b].toString().equals("@annotations.Or2()")
)
{
isOptional.set(a, true);
numOptional++;
if (depth != -1)
report.addLog(" [Opt] (or an Or)");
}
else if (annos[a][b].toString().equals("@annotations.Name()"))
{
name[a] = params[a].getName();
if (Character.isUpperCase(name[a].charAt(0)))
{
// First char is capital, probably If, Else, etc.
name[a] = Character.toLowerCase(name[a].charAt(0)) + name[a].substring(1);
}
if (depth != -1)
report.addLog(" [name=" + name[a] + "]");
}
}
if (depth != -1)
report.addLogLine("");
}
if (argsIn.size() < numSlots - numOptional)
{
if (depth != -1)
report.addLogLine(pre + "Not enough input args (" + argsIn.size() + ") for non-optional constructor args (" + (numSlots - numOptional) + ").");
continue;
}
// Try possible combinations of input arguments
final Object[] argObjects = new Object[numSlots];
// Try arg combinations
final List<List<Arg>> combos = argCombos(argsIn, numSlots);
for (int cmb = 0; cmb < combos.size(); cmb++)
{
final List<Arg> combo = combos.get(cmb);
// Create a potential call for this combination
call = new Call(CallType.Class, instance, expected);
if (depth != -1)
{
report.addLog(pre);
int count = 0;
for (int n = 0; n < combo.size(); n++)
{
final Arg arg = combo.get(n);
report.addLog((arg == null ? "-" : Character.valueOf((char)('A' + count))) + " ");
if (arg != null)
count++;
}
report.addLogLine("");
}
// Attempt to match this combination of args
int slot;
// Quick pre-test: abort if any null argIn is not an optional parameter
for (slot = 0; slot < numSlots; slot++)
if (combo.get(slot) == null && !isOptional.get(slot))
break;
if (slot < numSlots)
continue;
for (slot = 0; slot < numSlots; slot++)
{
argObjects[slot] = null;
final Arg argIn = combo.get(slot);
if (depth != -1)
{
report.addLog(pre + "argIn " + slot + ": ");
report.addLogLine(argIn == null ? "null" : (argIn.symbolName() + " (" + argIn.getClass().getName() +")") + ".");
}
if (depth != -1)
{
if (argIn != null && argIn.parameterName() != null)
report.addLogLine(pre + "argIn has parameterName: " + argIn.parameterName());
}
if (argIn == null)
{
// Null placeholder for this slot
if (!isOptional.get(slot))
break;
if (callNode != null)
{
// Add null placeholder arg
call.addArg(new Call(CallType.Null));
}
}
else
{
// This argIn must compile!
if (name[slot] != null && (argIn.parameterName() == null || !argIn.parameterName().equals(name[slot])))
{
// argIn name does not match named constructor parameter
if (depth != -1)
{
report.addLogLine(pre + "- Named arg '" + name[slot] + "' in constructor does not match argIn parameterName '" + argIn.parameterName() + "'.");
}
break;
}
if (argIn.parameterName() != null && (name[slot] == null || !argIn.parameterName().equals(name[slot])))
{
// Named argIn does not match constructor parameter name
if (depth != -1)
{
report.addLogLine(pre + "- Named argIn '" + argIn.parameterName() + "' does not match parameter constructor arg label '" + name[slot] + "'.");
}
break;
}
// ArgIn must match the constructor argument for this slot!
// **
// ** Check here that candidate arg can possibly match the known arg.
// ** Small saving on time if used, but greatly reduces error log size.
// ** Doesn't work for Omega (4-player option) and Temeen Tavag (Square option).
// **
// if (argIn.matchingInstance(types[slot]) == null)
// {
// //System.out.println("++ argIn " + argIn + " doesn't match type " + types[slot]);
// break; // the arg at this slot doesn't match the required arg
// }
final Call callDummy = (callNode == null) ? null : new Call(CallType.Null);
final Object match = argIn.compile
(
types[slot],
(depth == -1 ? -1 : depth+1),
report,
callDummy,
hasCompiled
);
if (match == null)
{
// Can't compile argIn for this constructor parameter
if (depth != -1)
report.addLogLine(pre + "- Arg '" + argIn.toString() + "' doesn't match '" + types[slot] + ".");
break;
}
// Arguments match
argObjects[slot] = match;
if (callNode != null && callDummy.args().size() > 0)
{
// Add a call for this argument
final Call argCall = callDummy.args().get(0);
if (name[slot] != null)
argCall.setLabel(name[slot]);
call.addArg(argCall);
}
if (depth != -1)
{
report.addLogLine(pre + "arg " + slot + " corresponds to " + argIn + ",");
report.addLogLine(pre + " returned match " + match + " for expected " + types[slot]);
}
}
}
if (slot >= numSlots)
{
// All args match, no conflicts, all slots have a valid object or are null (and optional).
if (depth != -1)
report.addLogLine(pre + "++ Matched all input args.");
if (depth != -1)
{
report.addLogLine(pre + " Trying to create instance of " + exec.getName() + " with " + argObjects.length + " args:");
for (int o = 0; o < argObjects.length; o++)
report.addLogLine(pre + " - argObject " + o + ": " +
((argObjects[o] == null) ? "null" : argObjects[o].toString()));
}
try
{
if (tryConstructors)
object = ((Constructor<?>)exec).newInstance(argObjects);
else
object = ((Method)exec).invoke(null, argObjects);
}
catch (final Exception e)
{
// Failed to compile
// **
// ** Turn these error logs back on for full stack trace,
// ** but can be annoying as this case will legitimately
// ** occur many times for some games.
// **
//report.addLogLine("***************************");
//e.printStackTrace();
// Possibly an initialisation error, e.g. null placeholder for Integer parameter
if (depth != -1)
{
report.addLogLine(pre + "\n" + pre + "*********************");
report.addLogLine(pre + "Failed to create new instance (with args).");
report.addLogLine(pre + "Expected types:");
for (final Type type : types)
report.addLogLine(pre + "= " + type);
report.addLogLine(pre + "Actual argObjects:");
for (final Object obj : argObjects)
report.addLogLine(pre + "= " + obj);
report.addLogLine(pre + "*********************\n");
}
}
if (object != null)
{
// Successfully compiled object
if (callNode != null)
callNode.addArg(call);
break;
}
}
}
}
if (object != null)
break; // successfully compiled object
}
if (object != null)
{
//System.out.println("Compiled " + object.getClass().getName());
if (depth != -1)
{
report.addLogLine(pre + "------------------------------");
report.addLogLine(pre + "Compiled object " + object + " (key=" + key + ") successfully.");
report.addLogLine(pre + "------------------------------");
}
instance.setObject(object);
// Expected class was compiled (but possibly as return type!)
hasCompiled.put(key, Boolean.TRUE);
// Also indicate object type was compiled, to be sure.
hasCompiled.put(object.getClass().getName(), Boolean.TRUE);
//System.out.println("+ Did compile: " + key);
return object;
}
}
if (symbolName.equals("game"))
{
throw new BadSyntaxException("game", "Could not create \"game\" ludeme from description.");
}
if (symbolName.equals("match"))
{
throw new BadSyntaxException("match", "Could not create a \"match\" ludeme from description.");
}
return null; // no match found
}
//-------------------------------------------------------------------------
/**
* @param args
* @param numSlots
* @return List of possible arg combinations padded with nulls to give length.
*/
private static List<List<Arg>> argCombos(final List<Arg> args, final int numSlots)
{
final List<List<Arg>> combos = new ArrayList<List<Arg>>();
final Arg[] current = new Arg[numSlots];
for (int i = 0; i < current.length; i++)
current[i] = null;
argCombos(args, numSlots, 0, 0, current, combos);
// for (final int[] indices : Constants.combos[args.size()][numSlots])
// {
// final List<Arg> combo = new ArrayList<Arg>();
// for (int n = 0; n < numSlots; n++)
// combo.add(indices[n] == 0 ? null : args.get(indices[n]-1));
// combos.add(combo);
// }
return combos;
}
private static void argCombos
(
final List<Arg> args, final int numSlots, final int numUsed, final int slot,
final Arg[] current, final List<List<Arg>> combos
)
{
if (numUsed > args.size())
{
// Overshot -- too many null placeholders to allow all args to be placed
return;
}
if (slot == numSlots)
{
// All slots filled
if (numUsed < args.size())
return; // all args not used
// Combo completed -- store in list
final List<Arg> combo = new ArrayList<Arg>();
for (int n = 0; n < numSlots; n++)
combo.add(current[n]);
combos.add(combo);
return;
}
if (numUsed < args.size())
{
// Try next arg in next slot
current[slot] = args.get(numUsed);
argCombos(args, numSlots, numUsed+1, slot+1, current, combos);
current[slot] = null;
}
// Try null placeholder
argCombos(args, numSlots, numUsed, slot+1, current, combos);
}
//-------------------------------------------------------------------------
@Override
public String toString()
{
String strT = "";
if (parameterName != null)
strT += parameterName + ":";
strT += "(" + symbolName;
if (argsIn.size() > 0)
for (final Arg arg : argsIn)
strT += " " + arg.toString();
strT += ")";
return strT;
}
//-------------------------------------------------------------------------
}
| 21,102 | 27.1749 | 158 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/ArgTerminal.java
|
package compiler;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import compiler.exceptions.TerminalNotFoundException;
//import game.functions.booleans.BooleanConstant;
//import game.functions.dim.DimConstant;
//import game.functions.floats.FloatConstant;
//import game.functions.ints.IntConstant;
import grammar.Grammar;
import main.StringRoutines;
import main.grammar.Call;
import main.grammar.Call.CallType;
import main.grammar.Instance;
import main.grammar.Report;
import main.grammar.Symbol;
import main.grammar.Symbol.LudemeType;
//-----------------------------------------------------------------------------
/**
* Token argument in constructor argument list. The token may be a:
* 1. String: in which case "str" will have surrounding quotes.
* 2. Integer: in which case it will satisfy Global.isInteger(str).
* 3. Boolean: in which case it will be "true" or "false".
* 4. Enum constant: in which case str will have at least one matching symbol in the grammar.
* @author cambolbro
*/
public class ArgTerminal extends Arg
{
//-------------------------------------------------------------------------
/**
* Constructor
* @param name Symbol name.
* @param label Optional parameter label.
*/
public ArgTerminal(final String name, final String label)
{
super(name, label);
}
//-------------------------------------------------------------------------
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public boolean matchSymbols(final Grammar grammar, final Report report)
{
Object object = null;
Symbol symbol = null;
final String className = StringRoutines.upperCaseInitial(symbolName);
final List<Symbol> match = grammar.symbolsByName(className);
final List<Symbol> symbols = (match == null) ? null : new ArrayList(match);
instances.clear();
if (symbols == null || Grammar.applicationConstantIndex(symbolName) != -1)
{
// Check if is a known type
if
(
symbolName.length() >= 2
&&
symbolName.charAt(0) == '\"'
&&
symbolName.charAt(symbolName.length() - 1) == '\"'
)
{
// Is a String
symbol = grammar.symbolsByName("String").get(0);
// System.out.println("* arg " + symbolName + " has " + instances.size() + " matches (String).");
String str = symbolName;
while (str.contains("\""))
str = str.replace("\"", "");
object = new String(str);
instances.add(new Instance(symbol, object));
}
else if
(
StringRoutines.isInteger(symbolName)
||
Grammar.applicationConstantIndex(symbolName) != -1
)
{
// Is an integer
int value;
final int acIndex = Grammar.applicationConstantIndex(symbolName);
final String valueName = (acIndex == -1) ? symbolName : Grammar.ApplicationConstants[acIndex][3];
final String constantName = (acIndex == -1) ? null : symbolName;
try
{
value = Integer.parseInt(valueName);
}
catch (NumberFormatException e)
{
e.printStackTrace();
return false;
}
catch (NullPointerException e)
{
e.printStackTrace();
return false;
}
// 1. IntConstant version
//object = new IntConstant(value);
try
{
// Load class from Core (is outside build path)
object = Class.forName("game.functions.ints.IntConstant")
.getDeclaredConstructor(int.class)
.newInstance(Integer.valueOf(value));
}
catch (Exception e)
{
e.printStackTrace();
}
symbol = grammar.symbolsByName("IntConstant").get(0);
instances.add(new Instance(symbol, object, constantName));
// 1a. DimConstant version
//object = new DimConstant(value);
try
{
// Load class from Core (is outside build path)
object = Class.forName("game.functions.dim.DimConstant")
.getDeclaredConstructor(int.class)
.newInstance(Integer.valueOf(value));
}
catch (Exception e)
{
e.printStackTrace();
}
symbol = grammar.symbolsByName("DimConstant").get(0);
instances.add(new Instance(symbol, object, constantName));
// 2. Integer version
symbol = grammar.symbolsByName("Integer").get(0);
object = Integer.valueOf(value);
instances.add(new Instance(symbol, object, constantName));
// 3. Primitive int version
symbol = grammar.symbolsByName("int").get(0);
object = Integer.valueOf(value);
instances.add(new Instance(symbol, object, constantName));
// System.out.println("* arg " + symbolName + " has " + instances.size() + " matches (value=" + value + ").");
}
else if (symbolName.equalsIgnoreCase("true") || symbolName.equalsIgnoreCase("false"))
{
// Is a boolean
boolean value = symbolName.equalsIgnoreCase("true");
// 1. BooleanConstant version
//object = BooleanConstant.construct(value);
try
{
// Load class from Core (is outside build path)
object = Class.forName("game.functions.booleans.BooleanConstant")
.getDeclaredConstructor(boolean.class)
.newInstance(Boolean.valueOf(value));
}
catch (Exception e)
{
e.printStackTrace();
}
symbol = grammar.symbolsByName("BooleanConstant").get(0);
instances.add(new Instance(symbol, object));
// 2. Boolean version
symbol = grammar.symbolsByName("Boolean").get(0);
object = Boolean.valueOf(value);
instances.add(new Instance(symbol, object));
// 3. Primitive boolean version
symbol = grammar.symbolsByName("boolean").get(0); // null;
object = Boolean.valueOf(value);
instances.add(new Instance(symbol, object));
// System.out.println("* arg " + symbolName + " has " + instances.size() + " matches (value=" + value + ").");
}
// 2. Check if is a predefined data type?
// 3. Check if is a named item?
// 4. Check if is a named ludeme?
else
{
// Can't match it with anything
// symbols = grammar.symbolMap().get("String");
// System.out.println("!! arg " + symbolName + " has no matches.");
}
if
(
StringRoutines.isFloat(symbolName)
)
{
// Is a float
float value;
final String valueName = symbolName;
try
{
value = Float.parseFloat(valueName);
}
catch (NumberFormatException e)
{
e.printStackTrace();
return false;
}
catch (NullPointerException e)
{
e.printStackTrace();
return false;
}
// 1. FloatConstant version
//object = new FloatConstant(value);
try
{
// Load class from Core (is outside build path)
object = Class.forName("game.functions.floats.FloatConstant")
.getDeclaredConstructor(float.class)
.newInstance(Float.valueOf(value));
}
catch (Exception e)
{
e.printStackTrace();
}
symbol = grammar.symbolsByName("FloatConstant").get(0);
instances.add(new Instance(symbol, object));
// 2. Float version
symbol = grammar.symbolsByName("Float").get(0);
object = Float.valueOf(value);
instances.add(new Instance(symbol, object));
// 3. Primitive float version
symbol = grammar.symbolsByName("float").get(0);
object = Float.valueOf(value);
instances.add(new Instance(symbol, object));
// System.out.println("* arg " + symbolName + " has " + instances.size() + " matches (value=" + value + ").");
}
}
else
{
// At least one matching symbol
for (final Symbol sym : symbols)
{
if (sym.ludemeType() == LudemeType.Constant)
{
// Is probably an enum
final Class<?> cls = sym.cls();
// FIXME: Add placeholder object to match number of entries in lists?
// Or add object?
if (cls == null)
{
System.out.println("** ArgTerminal: null cls, symbolName=" + symbolName + ", parameterName=" + parameterName);
report.addLogLine("** ArgTerminal: null cls, symbolName=" + symbolName + ", parameterName=" + parameterName);
}
Object[] enums = cls.getEnumConstants();
if (enums != null && enums.length > 0)
{
for (Object obj : enums)
{
// System.out.println(" obj: " + obj);
if (obj.toString().equals(sym.token()))
{
final Instance instance = new Instance(sym, obj);
instances.add(instance);
}
}
}
// if (instance.cls() != null)
// break; // success!
}
else
{
// FIXME: Check this. Should these be set by their relevant class?
}
}
}
if (instances.size() == 0)
{
// System.out.println("!! arg " + symbolName + " has no instance after matching symbols.");
return false;
}
return true;
}
//-------------------------------------------------------------------------
@Override
public Object compile
(
final Class<?> expected, final int depth, final Report report,
final Call callNode, final Map<String, Boolean> hasCompiled
)
{
final String key = expected.getName() + " (terminal)";
if (!hasCompiled.containsKey(key))
hasCompiled.put(key, Boolean.FALSE);
String pre = "";
for (int n = 0; n < depth; n++)
pre += ". ";
pre += "T: ";
if (depth != -1)
{
//System.out.println("\n" + pre + "Compiling ArgTerminal: " + toString());
//System.out.println(pre + "Trying expected type: " + expected);
report.addLogLine("\n" + pre + "Compiling ArgTerminal: " + toString());
report.addLogLine(pre + "Trying expected type: " + expected);
}
if (depth != -1)
{
for (Instance instance : instances)
{
final Symbol symbol = instance.symbol();
//System.out.println(pre + "T: > " + symbol + " (" + symbol.path() + ") " + symbol.keyword() + ".");
report.addLogLine(pre + "T: > " + symbol + " (" + symbol.path() + ") " + symbol.token() + ".");
}
}
if (depth != -1)
{
//System.out.println(pre + "Instances:");
report.addLogLine(pre + "Instances:");
}
for (int n = 0; n < instances.size(); n++)
{
final Instance instance = instances.get(n);
if (depth != -1)
{
// System.out.println
// (
// pre + "\n" + pre +
// "Instance " + n + " is " + instance.symbol().grammarLabel() +
// ": symbol=" + instance.symbol() +
// " (path=" + instance.symbol().path() + ")."
// );
report.addLogLine
(
pre + "\n" + pre +
"Instance " + n + " is " + instance.symbol().grammarLabel() +
": symbol=" + instance.symbol() +
" (path=" + instance.symbol().path() + ")."
);
}
final Class<?> cls = instance.cls();
if (depth != -1)
{
//System.out.println(pre + "- cls is: " + (cls == null ? "null" : cls.getName()));
report.addLogLine(pre + "- cls is: " + (cls == null ? "null" : cls.getName()));
}
if (cls == null)
{
//System.out.println(pre + "- unexpected null cls.");
report.addLogLine(pre + "- unexpected null cls.");
throw new TerminalNotFoundException(expected.getName());
}
if (expected.isAssignableFrom(cls))
{
//System.out.println("Terminal match: " + instance.object());
if (depth != -1)
{
//System.out.println(pre + "+ MATCH! Returning object " + instance.object());
report.addLogLine(pre + "+ MATCH! Returning object " + instance.object());
}
if (callNode != null)
{
// Create a terminal object Call for this item
final Call call = new Call(CallType.Terminal, instance, expected);
callNode.addArg(call);
}
hasCompiled.put(key, Boolean.TRUE);
return instance.object();
//final List<Object> objects = new ArrayList<Object>();
//objects.add(instance.object());
//return objects;
}
}
if (depth != -1)
{
//System.out.println(pre + "\n" + pre + "* Failed to compile ArgTerminal: " + toString());
report.addLogLine(pre + "\n" + pre + "* Failed to compile ArgTerminal: " + toString());
}
//throw new TerminalNotFoundException(expected.getName());
return null;
}
//-------------------------------------------------------------------------
@Override
public String toString()
{
return (parameterName == null ? "" : parameterName + ":") + symbolName;
}
//-------------------------------------------------------------------------
}
| 12,197 | 26.977064 | 116 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/Compiler.java
|
package compiler;
import java.io.File;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import compiler.exceptions.CantDecomposeException;
import compiler.exceptions.CompilerErrorWithMessageException;
import compiler.exceptions.CompilerException;
import compiler.exceptions.CreationErrorWithMessageException;
import compiler.exceptions.NullGameException;
import grammar.Grammar;
import main.grammar.Call;
import main.grammar.Call.CallType;
import main.grammar.Description;
import main.grammar.Report;
import main.grammar.Symbol;
import main.grammar.Symbol.LudemeType;
import main.grammar.Token;
import main.options.UserSelections;
import parser.Parser;
//-----------------------------------------------------------------------------
/**
* Compiles game descriptions in the Ludii class grammar format to executable
* Game objects, if possible.
*
* @author cambolbro
*/
public class Compiler
{
// Avoid warning about failure to close resource
private static ClassLoader classLoader;
//-------------------------------------------------------------------------
/**
* Default private constructor; can't be called directly.
*/
private Compiler()
{
}
//-------------------------------------------------------------------------
/**
* Compile option for testing purposes. Does not interact with UI settings. Not
* for release! Create and throws away GameOptions each time.
*
* Cast the returned object to (Game) in order to use it!
*
* @param description The description.
* @param isVerbose True if this is verbose.
* @return Executable Game object if can be compiled, else null.
*/
public static Object compileTest
(
final Description description,
final boolean isVerbose
)
{
final Object game = compile
(
description,
new UserSelections(new ArrayList<String>()),
new Report(),
isVerbose
);
if (game == null)
System.out.println("** Compiler.compileTest(): Game compiled but returned null after initialisation.");
return game;
}
//-------------------------------------------------------------------------
/**
* Cast the returned object to (Game) in order to use it!
*
* @param description The description.
* @param userSelections The user selections.
* @param report The report.
* @param isVerbose True if this is verbose.
* @return Executable Game object if can be compiled, else null.
*/
public static Object compile
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean isVerbose
)
{
try
{
return compileActual(description, userSelections, report, isVerbose);
}
catch (final CompilerException e)
{
//if (isVerbose)
e.printStackTrace();
throw new CompilerException(e.getMessageBody(description.raw()), e);
}
catch (final Exception e)
{
e.printStackTrace();
throw new IllegalArgumentException(e);
}
}
//-------------------------------------------------------------------------
/**
* @return Compiled Game object else null.
*/
private static Object compileActual
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean isVerbose
)
{
if (isVerbose)
{
//System.out.println("+++++++++++++++++++++\nCompiling:\n" + description.raw());
report.addLogLine("+++++++++++++++++++++\nCompiling:\n" + description.raw());
}
// System.out.println("\nAt Compiler.compiler(), current option selections are:\n "
// + options.currentSelectionsAsString() + " => " + options.toStrings());
//final Parser parser = Parser.getParser(); //new Parser();
// if (!parser.parse(description, userSelections, isVerbose))
// throw new CompilerErrorWithMessageException("Failed to parse game description.");
Parser.expandAndParse(description, userSelections, report, true, isVerbose);
if (report.isError())
{
System.out.println("Failed to parse game description:");
for (final String error : report.errors())
{
System.out.println("* " + error);
report.addLogLine("* " + error);
}
final StringBuilder sb = new StringBuilder();
//sb.append(description.expanded());
for (final String error : report.errors())
sb.append(error + "\n");
for (final String warning : report.warnings())
sb.append("Warning: " + warning + "\n");
for (final String note : report.notes())
sb.append("Note: " + note + "\n");
throw new CompilerErrorWithMessageException(sb.toString());
//throw new RuntimeException(sb.toString());
// return null;
}
// System.out.println("Expanded description:\n" + gameDescription.expandedDescription());
// System.out.println("Metadata description:\n" + gameDescription.metadataDescription());
// boolean isMatch = false;
// final int matchAt = gameDescription.expandedDescription().indexOf("(match");
// if (matchAt >= 0)
// {
// final char ch = gameDescription.expandedDescription().charAt(matchAt + 6);
// if (!StringRoutines.isTokenChar(ch)) // avoid superstrings e.g. "(matchScore"
// isMatch = true;
// }
//Game game = null;
// Match match = null;
// if (isMatch)
// {
// // Compile match
// match = (Match)compileTask
// (
// gameDescription.expandedDescription(), "match", "game.Match", isVerbose
// );
// }
// else
// {
final Object game = compileTask
(
description.expanded(),
"game",
"game.Game",
report,
isVerbose,
description
);
if (game == null)
{
System.out.println("** Compiler.compiler(): Could not compile game.");
return null;
}
try
{
// If the report object has a messenger attached, print this message using it.
// final Method gameName = game.getClass().getMethod("name");
//
// if (report.getReportMessageFunctions() != null)
// report.getReportMessageFunctions().printMessageInStatusPanel
// (
//// "Compiled " + game.name() + " successfully.\n"
// "Compiled " + gameName.invoke(game) + " successfully.\n"
// );
// Associate the game with its description
//game.setDescription(description);
final Method gameSetDescription = game.getClass().getMethod("setDescription", Description.class);
gameSetDescription.invoke(game, description);
}
catch (final Exception e)
{
e.printStackTrace();
}
// Check that the game can be created
try
{
//game.create();
final Method gameCreate = game.getClass().getMethod("create");
gameCreate.invoke(game);
}
catch (final Error e)
{
String msg = "Error during game creation: " + e;
final boolean isStackOverflow = e.getClass().getName().contains("StackOverflowError");
if (isStackOverflow)
{
msg = "Error: Stack overflow during game creation.\n" +
"Check for recursive rules, e.g. (forEach Piece ...) within a piece.";
}
report.addError(msg);
throw new CreationErrorWithMessageException(msg);
}
catch (final Exception e)
{
e.printStackTrace();
final String msg = "Exception during game creation: " + e;
report.addError(msg);
throw new CreationErrorWithMessageException(msg);
}
// }
// System.out.println("Game created. Compiling metadata...");
// Compile metadata
//System.out.println("Compiling metadata string:\n" + parser.metadataString());
Object md = null;
if (description.metadata() != null && description.metadata() != "")
{
md = compileTask
(
description.metadata(), "metadata", "metadata.Metadata", report, isVerbose, null
);
}
if (md == null)
{
//md = new Metadata(null, null, null);
try
{
md = loadExternalClass
(
"../Core/src/metadata/",
"metadata.Metadata"
)
.getDeclaredConstructor()
.newInstance();
} catch (final Exception e)
{
e.printStackTrace();
}
}
try
{
//game.setMetadata(md);
final Method gameSetMetadata = game.getClass().getMethod("setMetadata", Object.class);
gameSetMetadata.invoke(game, md);
//game.setOptions(userSelections.selectedOptionStrings());
final Method gameSetOptions = game.getClass().getMethod("setOptions", List.class);
gameSetOptions.invoke(game, userSelections.selectedOptionStrings());
}
catch (final Exception e)
{
e.printStackTrace();
}
// System.out.println("Game is: " + game.name());
// System.out.print("Aliases are: ");
// for (final String alias : game.metadata().info().getAliases())
// System.out.print(" " + alias);
// System.out.println();
// if (game != null)
// return game;
//
// return match;
return game;
}
//-------------------------------------------------------------------------
/**
* Compiles an object from an arbitrary class from given string (in ludeme-like
* format).
*
* This method should not be used for full game objects, but only for smaller
* objects that may typically be found deeper inside Game or Metadata objects.
*
* Does not support any more advanced mechanisms like options, defines, etc.
*
* @param strIn
* @param className Fully qualified name of type of Object that we're expecting
* @param report The report.
* @return Compiled object, or null if failed to compile.
*/
public static Object compileObject
(
final String strIn,
final String className,
final Report report
)
{
final String[] classNameSplit = className.split(Pattern.quote("."));
//final String symbolName = StringRoutines.lowerCaseInitial(classNameSplit[classNameSplit.length - 1]);
final String symbolName = classNameSplit[classNameSplit.length - 1];
return compileObject(strIn, symbolName, className, report);
}
/**
* Compiles an object from an arbitrary class from given string (in ludeme-like
* format).
*
* This method should not be used for full game objects, but only for smaller
* objects that may typically be found deeper inside Game or Metadata objects.
*
* Does not support any more advanced mechanisms like options, defines, etc.
*
* @param strIn
* @param symbolName The symbol name (usually last part of className, or an
* alias)
* @param className Fully qualified name of type of Object that we're expecting
* @param report The report.
* @return Compiled object, or null if failed to compile.
*/
public static Object compileObject
(
final String strIn,
final String symbolName,
final String className,
final Report report
)
{
return compileTask(strIn, symbolName, className, report, false, null);
// final Object result = compileTask(strIn, symbolName, className, false);
// if (result == null)
// compileTask(strIn, symbolName, className, true);
// return result;
}
//-------------------------------------------------------------------------
/**
* Compile option for reconstruction testing purposes. Does not interact with UI settings. Not
* for release! Create and throws away GameOptions each time.
*
* Cast the returned object to (Game) in order to use it!
*
* @param description The description.
* @param isVerbose True if this is verbose.
* @return Executable Game object if can be compiled, else null.
*/
public static Object compileReconsTest
(
final Description description,
final boolean isVerbose
)
{
final Object game = compileRecons
(
description,
new UserSelections(new ArrayList<String>()),
new Report(),
isVerbose
);
if (game == null)
System.out.println("** Compiler.compileTest(): Game compiled but returned null after initialisation.");
return game;
}
//-------------------------------------------------------------------------
/**
* Cast the returned object to (Game) in order to use it! Do not print any exception.
*
* @param description The description.
* @param userSelections The user selections.
* @param report The report.
* @param isVerbose True if this is verbose.
* @return Executable Game object if can be compiled, else null.
*/
public static Object compileRecons
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean isVerbose
)
{
try
{
return compileActual(description, userSelections, report, isVerbose);
}
catch (final CompilerException e)
{
//if (isVerbose)
// e.printStackTrace();
throw new CompilerException(e.getMessageBody(description.raw()), e);
}
catch (final Exception e)
{
// e.printStackTrace();
throw new IllegalArgumentException(e);
}
}
//-------------------------------------------------------------------------
/**
* Compile either the Game object or the Metadata object.
* @return Compiled object, else null if error.
*/
private static Object compileTask
(
final String strIn,
final String symbolName,
final String className,
final Report report,
final boolean isVerbose,
final Description description
)
{
// /**
// * List of ludemes to ignore if found not to compile. These are typically
// * ludemes automatically generated as defaults for enclosing ludemes
// * that can but do not actually appear in the game description.
// */
// final Map<String, String> ignoreNonCompiledLudemes = new HashMap<String, String>();
// {
//// ignoreNonCompiledLudemes.put("java.lang.Integer", "java.lang.Integer");
//// ignoreNonCompiledLudemes.put("java.lang.String", "java.lang.String");
//// ignoreNonCompiledLudemes.put("game.rules.meta.Meta", "game.rules.meta.Meta");
//// ignoreNonCompiledLudemes.put("game.util.moves.Player", "game.util.moves.Player");
//// ignoreNonCompiledLudemes.put("game.util.moves.From", "game.util.moves.From");
//// ignoreNonCompiledLudemes.put("game.util.moves.To", "game.util.moves.To");
//// ignoreNonCompiledLudemes.put("game.util.moves.Between", "game.util.moves.Between");
//// ignoreNonCompiledLudemes.put("game.util.moves.Flips", "game.util.moves.Flips");
//// ignoreNonCompiledLudemes.put("game.util.moves.Piece", "game.util.moves.Piece");
//// ignoreNonCompiledLudemes.put("game.rules.start.Start", "game.rules.start.Start");
//// ignoreNonCompiledLudemes.put("game.mode.Mode", "game.mode.Mode");
//// ignoreNonCompiledLudemes.put("game.functions.intArray.state.Rotations", "game.functions.intArray.state.Rotations");
//// ignoreNonCompiledLudemes.put("metadata.graphics.Graphics", "metadata.graphics.Graphics");
//// ignoreNonCompiledLudemes.put("metadata.ai.heuristics.Heuristics", "metadata.ai.heuristics.Heuristics");
//// ignoreNonCompiledLudemes.put("game.equipment.container.board.Track", "game.equipment.container.board.Track");
// //ignoreNonCompiledLudemes.put("", "");
// //ignoreNonCompiledLudemes.put("", "");
// //ignoreNonCompiledLudemes.put("", "");
// };
//System.out.println("parser.metadataString:\n" + parser.metadataString());
// System.out.println("\nCompiling description starting: " + strIn.substring(0, 20));
// System.out.println("symbolName is: " + symbolName);
final Token tokenTree = new Token(strIn, report);
if (isVerbose)
{
//System.out.println("\nCompiler.compileTask() token tree:\n" + tokenTree);
report.addLogLine("\nCompiler.compileTask() token tree:\n" + tokenTree);
}
if (tokenTree.type() == null)
{
//System.out.println("** Compiler.compileTask(): Null token tree.");
report.addLogLine("** Compiler.compileTask(): Null token tree.");
if (symbolName.equals("game")) // || symbolName.equals("match"))
throw new CantDecomposeException("CompilercompileTask()"); // must have a game object!
else
return null; // may be no metadata
}
final ArgClass rootClass = (ArgClass)Arg.createFromToken(Grammar.grammar(), tokenTree);
if (rootClass == null)
throw new NullGameException();
if (isVerbose)
{
//System.out.println("\nRoot:" + rootClass);
report.addLogLine("\nRoot:" + rootClass);
}
// Eric: commented for the match
// if (!rootClass.symbolName().equals(symbolName))
// {
// System.out.println("rootClass is: " + rootClass.symbolName() + ", symbolName is: " + symbolName);
// throw new BadRootException(rootClass.symbolName(), symbolName);
// }
final Grammar grammar = Grammar.grammar();
if (!rootClass.matchSymbols(grammar, report))
{
System.out.println("Compiler.compileTask(): Failed to match symbols.");
report.addLogLine("Compiler.compileTask(): Failed to match symbols.");
throw new CompilerErrorWithMessageException("Failed to match symbols when compiling.");
}
// Attempt to compile the game
Class<?> clsRoot = null;
try
{
clsRoot = Class.forName(className);
} catch (final ClassNotFoundException e)
{
e.printStackTrace();
}
// Create call tree with dummy root
Call callTree = (description == null) ? null : new Call(CallType.Null);
final Map<String, Boolean> hasCompiled = new HashMap<>();
final Object result = rootClass.compile(clsRoot, (isVerbose ? 0 : -1), report, callTree, hasCompiled);
// Check fragments that did not compile
for (final Map.Entry<String, Boolean> entry : hasCompiled.entrySet())
{
//System.out.println("key: " + entry.getKey());
if (entry.getValue() == Boolean.TRUE)
continue; // item did compile
final String path = entry.getKey();
// if (ignoreNonCompiledLudemes.containsKey(path))
// continue; // ignore certain classes
final Symbol symbol = grammar.findSymbolByPath(path);
if (symbol == null) // || !symbol.usedInDescription())
continue; // is probably a primitive type or structural <rule> ludeme
if (symbol.ludemeType() == LudemeType.Structural)
continue; // don't include structural ludemes
//System.out.println(path);
//System.out.println("symbol: " + symbol + ", name: " + symbol.name());
// final Boolean check = hasCompiled.get(symbol.returnType().cls().getName());
// if (check == Boolean.TRUE)
// continue; // symbol's return type compiled successfully
System.out.println("** Could not compile " + path + ".");
report.addWarning("Could not compile " + path + ".");
//report.addError("Could not compile " + path + ".");
//report.addLogLine("Could not compile " + path + ".");
if (report.getReportMessageFunctions() != null)
report.getReportMessageFunctions().printMessageInStatusPanel("WARNING: Could not compile " + path + ".\n");
}
if (description != null)
{
// Remove dummy root from call tree and store it
if (callTree == null || callTree.args().isEmpty())
System.out.println("Compiler.compileTask: Bad call tree.");
callTree = callTree.args().isEmpty() ? null : callTree.args().get(0);
description.setCallTree(callTree);
//System.out.println(description.callTree());
// callTree.export("call-tree-" + ((Game)result).name() + ".txt");
}
if (isVerbose)
System.out.println(report.log());
if (result == null)
{
//System.out.println("Compiler.compileTask(): Null result from compiling root ArgClass object.");
report.addLogLine("Compiler.compileTask(): Null result from compiling root ArgClass object.");
throw new NullGameException();
}
//System.out.println("Compiled task:\n" + result.toString());
return result;
}
//-------------------------------------------------------------------------
public static Class<?> loadExternalClass(final String folderPath, final String classPath)
{
Class<?> cls = null;
final String relPath = folderPath.replace('.', '/');
// Create a File object on the root of the directory containing the class file
final File file = new File(relPath); //folderPath);
try
{
// Convert File to a URL
final URL url = file.toURI().toURL();
final URL[] urls = new URL[] { url };
classLoader = new URLClassLoader(urls, Compiler.class.getClassLoader());
// Load in the class; MyClass.class should be located in
// the directory file:/c:/myclasses/com/mycompany
cls = classLoader.loadClass(classPath);
}
catch (final MalformedURLException e)
{
e.printStackTrace();
}
catch (final ClassNotFoundException e)
{
e.printStackTrace();
}
return cls;
}
//-------------------------------------------------------------------------
}
| 20,745 | 30.338369 | 122 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/ArrayTypeNotFoundException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class ArrayTypeNotFoundException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String expectedType;
/**
* @param expectedType
*/
public ArrayTypeNotFoundException(final String expectedType)
{
super();
this.expectedType = expectedType;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, expectedType, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "The array type " + expectedType + " was not found.";
}
}
| 1,043 | 19.470588 | 88 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadArrayElementException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadArrayElementException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String expectedType;
private final String elementType;
/**
* @param expectedType
* @param elementType
*/
public BadArrayElementException(final String expectedType, final String elementType)
{
super();
this.expectedType = expectedType;
this.elementType = elementType;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, elementType, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "Array element of type " + elementType + " but type " + expectedType + " expected.";
}
}
| 1,188 | 21.018519 | 93 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadComponentException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadComponentException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badComponentName;
/**
* @param badComponentName
*/
public BadComponentException(final String badComponentName)
{
super();
this.badComponentName = StringRoutines.toDromedaryCase(badComponentName);
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badComponentName, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "The component " + badComponentName + " is not defined. Try appending the player index.";
}
}
| 1,125 | 21.078431 | 98 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadImportException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadImportException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badFile;
/**
* @param badFile
*/
public BadImportException(final String badFile)
{
super();
this.badFile = badFile;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badFile, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "Failed to import " + badFile + ".";
}
}
| 980 | 18.235294 | 83 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadKeywordException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadKeywordException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badKeyword;
private final String message;
/**
* @param badKeyword
* @param message
*/
public BadKeywordException(final String badKeyword, final String message)
{
super();
this.badKeyword = badKeyword; //StringRoutines.toDromedaryCase(badKeyword);
this.message = message;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badKeyword, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
String str = "The keyword \"" + badKeyword + "\" cannot be recognised.";
if (message != null)
str += " " + message;
return str;
}
}
| 1,239 | 20.37931 | 86 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadRangeException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadRangeException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final int limit;
/**
* @param limit
*/
public BadRangeException(final int limit)
{
super();
this.limit = limit;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, "..", "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "A range \"..\" has exceeded the limit " + limit + ".";
}
}
| 978 | 18.196078 | 80 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadRootException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadRootException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badRoot;
private final String expectedRoot;
/**
* @param badRoot
* @param expectedRoot
*/
public BadRootException(final String badRoot, final String expectedRoot)
{
super();
this.badRoot = badRoot;
this.expectedRoot = expectedRoot;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badRoot, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "Root " + badRoot + " found rather than expected root " + expectedRoot + ".";
}
}
| 1,141 | 19.763636 | 86 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadSymbolException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadSymbolException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badSymbol;
/**
* @param badSymbol
*/
public BadSymbolException(final String badSymbol)
{
super();
this.badSymbol = badSymbol;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badSymbol, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "An error occurred when matching " + badSymbol + ".";
}
}
| 1,009 | 18.803922 | 85 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/BadSyntaxException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class BadSyntaxException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String keyword;
private final String message;
/**
* @param keyword
* @param message
*/
public BadSyntaxException(final String keyword, final String message)
{
super();
this.keyword = keyword;
this.message = message;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(keyword == null ? safeDescription : StringRoutines.highlightText(safeDescription, keyword, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "Syntax error: " + message;
}
}
| 1,105 | 19.481481 | 119 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/CantCompileException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
* @author cambolbro
*/
public class CantCompileException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badKeyword;
/**
* @param badKeyword
*/
public CantCompileException(final String badKeyword)
{
super();
this.badKeyword = StringRoutines.toDromedaryCase(badKeyword);
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badKeyword, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "Can't compile the ludeme \"" + badKeyword + "\".";
}
}
| 1,045 | 19.92 | 86 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/CantDecomposeException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class CantDecomposeException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String source;
/**
* @param source
*/
public CantDecomposeException(final String source)
{
super();
this.source = source;
}
@Override
public String getMessageBody(final String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(safeDescription);
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return source + ": The game description could not be decomposed into parts.";
}
}
| 971 | 17.692308 | 79 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/CompilerErrorWithMessageException.java
|
package compiler.exceptions;
//-----------------------------------------------------------------------------
/**
*
* @author cambolbro
*/
public class CompilerErrorWithMessageException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String message;
/**
* @param message
*/
public CompilerErrorWithMessageException(final String message)
{
super();
this.message = message;
}
@Override
public String getMessageBody(String gameDescription)
{
final StringBuilder sb = new StringBuilder();
// final String safeDescription = StringRoutines.escapeText(gameDescription);
// sb.append("<html>");
// sb.append("<h2>");
// sb.append(getMessageTitle());
// sb.append("</h2>");
// sb.append("<br/>");
// sb.append("<p>");
// sb.append(safeDescription);
// sb.append("</p>");
// sb.append("</html>");
sb.append(message);
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return message;
}
}
| 1,026 | 18.018519 | 79 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/CompilerException.java
|
package compiler.exceptions;
/**
* Compiler-specific exception hierarchy.
* @author cambolbro, mrraow
*/
public class CompilerException extends RuntimeException
{
private static final long serialVersionUID = 1L;
//-------------------------------------------------------------------------
/**
* @param messageBody
* @param e
*/
public CompilerException(String messageBody, CompilerException e)
{
super(messageBody, e);
}
/**
*
*/
public CompilerException()
{
super();
}
/**
* @param gameDescription The description of the game.
*
* @return The body message.
*/
public String getMessageBody(final String gameDescription)
{
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(gameDescription);
sb.append("</p>");
sb.append("</html>");
return sb.toString();
}
/**
* @return The message of the title.
*/
@SuppressWarnings("static-method")
public String getMessageTitle()
{
return "A compiler error has occurred.";
}
}
| 1,134 | 17.306452 | 76 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/CreationErrorWithMessageException.java
|
package compiler.exceptions;
/**
*
* @author cambolbro
*/
public class CreationErrorWithMessageException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String message;
/**
* @param message
*/
public CreationErrorWithMessageException(final String message)
{
super();
this.message = message;
}
@Override
public String getMessageBody(String gameDescription)
{
final StringBuilder sb = new StringBuilder();
sb.append(message);
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return message;
}
}
| 631 | 14.8 | 72 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/DefineExpansionException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class DefineExpansionException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String message;
/**
* @param msg
*/
public DefineExpansionException(final String msg)
{
super();
this.message = msg;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, "define", "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return message;
}
}
| 954 | 17.72549 | 84 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/InvalidOptionException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
* @author mrraow
*/
public class InvalidOptionException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String message;
/**
* @param message The message.
*/
public InvalidOptionException(final String message)
{
super();
this.message = message;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(safeDescription);
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return message;
}
}
| 912 | 17.26 | 76 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/ListNotSupportedException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class ListNotSupportedException extends CompilerException
{
private static final long serialVersionUID = 1L;
/**
* An exception for the not supported symbols.
*/
public ListNotSupportedException()
{
super();
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, "List", "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "List<> not supported as ludeme constructor argument.";
}
}
| 964 | 18.693878 | 82 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/NullGameException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class NullGameException extends CompilerException
{
private static final long serialVersionUID = 1L;
/**
* An exception for a null game.
*/
public NullGameException()
{
super();
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, "game", "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "The game could not be compiled, but no specific error was identified.";
}
}
| 951 | 18.428571 | 82 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/ParserException.java
|
package compiler.exceptions;
/**
* Parser-specific exception hierarchy.
* @author cambolbro, mrraow
*/
public class ParserException extends RuntimeException
{
private static final long serialVersionUID = 1L;
//-------------------------------------------------------------------------
/**
* @param messageBody The message.
* @param e The exception.
*/
public ParserException(String messageBody, ParserException e)
{
super(messageBody, e);
}
/**
*
*/
public ParserException()
{
super();
}
/**
* @param gameDescription The game description.
* @return The message to print.
*/
public String getMessageBody(final String gameDescription)
{
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(gameDescription);
sb.append("</p>");
sb.append("</html>");
return sb.toString();
}
/**
* @return The title of the message.
*/
@SuppressWarnings("static-method")
public String getMessageTitle()
{
return "A parser error has occurred.";
}
}
| 1,152 | 17.901639 | 76 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/TerminalNotFoundException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class TerminalNotFoundException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badTerminal;
/**
*
* @param badTerminal
*/
public TerminalNotFoundException(final String badTerminal)
{
super();
this.badTerminal = badTerminal;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badTerminal, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "The keyword " + badTerminal + " cannot be recognised.";
}
}
| 1,043 | 19.076923 | 87 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/UnclosedClauseException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class UnclosedClauseException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String badClause;
/**
* @param badClause
*/
public UnclosedClauseException(final String badClause)
{
super();
this.badClause = badClause;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, badClause, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "The clause \"" + badClause + "\" was not closed.";
}
}
| 1,017 | 18.960784 | 85 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/UnexpectedArrayException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class UnexpectedArrayException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String expectedType;
/**
* @param expectedType
*/
public UnexpectedArrayException(final String expectedType)
{
super();
this.expectedType = expectedType;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, expectedType, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "An array of type " + expectedType + " was found when expecting a different type.";
}
}
| 1,069 | 19.980392 | 92 |
java
|
Ludii
|
Ludii-master/Language/src/compiler/exceptions/UnknownArrayErrorException.java
|
package compiler.exceptions;
import main.StringRoutines;
/**
*
* @author cambolbro
*/
public class UnknownArrayErrorException extends CompilerException
{
private static final long serialVersionUID = 1L;
private final String expectedType;
private final String message;
/**
* @param expectedType
* @param message
*/
public UnknownArrayErrorException(final String expectedType, final String message)
{
super();
this.expectedType = expectedType;
this.message = message;
}
@Override
public String getMessageBody(String gameDescription)
{
final String safeDescription = StringRoutines.escapeText(gameDescription);
final StringBuilder sb = new StringBuilder();
sb.append("<html>");
sb.append("<h2>");
sb.append(getMessageTitle());
sb.append("</h2>");
sb.append("<br/>");
sb.append("<p>");
sb.append(StringRoutines.highlightText(safeDescription, expectedType, "font", "red"));
sb.append("</p>");
sb.append("</html>");
System.out.println(sb);
return sb.toString();
}
@Override
public String getMessageTitle()
{
return "An array of type " + expectedType + " suffered an unexpected error " + message + ". We apologise for any inconvenience";
}
}
| 1,209 | 21.407407 | 130 |
java
|
Ludii
|
Ludii-master/Language/src/completer/Completer.java
|
package completer;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import main.StringRoutines;
import main.grammar.Define;
import main.grammar.Report;
import parser.Expander;
//-----------------------------------------------------------------------------
/**
* Completes partial game descriptions ready for expansion.
* @author cambolbro
*/
public class Completer
{
public static final char CHOICE_DIVIDER_CHAR = '|';
private static final int MAX_PARENTS = 10;
private static final int MAX_RANGE = 1000;
//-------------------------------------------------------------------------
public static boolean needsCompleting(final String desc)
{
// Remove comments first, so that recon syntax can be commented out
// to not trigger a reconstruction without totally removing it.
final String str = Expander.removeComments(desc);
return str.contains("[") && str.contains("]");
}
//-------------------------------------------------------------------------
/**
* Creates all completions exhaustively.
* @param raw Partial raw game description.
* @param maxCompletions Maximum number of completions to make (default is 1, e.g. for Travis tests).
* @param report Report log for warnings and errors.
* @return List of completed (raw) game descriptions ready for expansion and parsing.
*/
public static List<Completion> completeExhaustive(final String raw, final int maxCompletions, final Report report)
{
System.out.println("Completer.complete(): Completing at most " + maxCompletions + " descriptions...");
final List<Completion> completions = new ArrayList<Completion>();
// Create list of alternative Descriptions, as each will need to be expanded
final Map<String, String> ludMap = getAllLudContents();
final Map<String, String> defMap = getAllDefContents();
final List<Completion> queue = new ArrayList<Completion>();
queue.add(new Completion(new String(raw)));
while (!queue.isEmpty())
{
final Completion comp = queue.remove(0);
if (!needsCompleting(comp.raw()))
{
// Completed!
completions.add(comp);
if (completions.size() >= maxCompletions)
return completions;
continue;
}
// Complete the next completion clause
nextCompletionExhaustive(comp, queue, ludMap, defMap, report);
}
return completions;
}
//-------------------------------------------------------------------------
/**
* Process next completion and add results to queue.
* Completes in order according to next available valid completion.
* @param queue
* @param report
*/
public static void nextCompletionExhaustive
(
final Completion completion, final List<Completion> queue,
final Map<String, String> ludMap, final Map<String, String> defMap,
final Report report
)
{
System.out.println("Completing next completion for raw string:\n" + completion.raw());
final String raw = completion.raw();
// Find opening and closing bracket locations
final int from = raw.indexOf("[");
final int to = StringRoutines.matchingBracketAt(raw, from);
// Get reconstruction clause (substring within square brackets)
final String left = raw.substring(0, from);
final String clause = raw.substring(from + 1, to);
final String right = raw.substring(to + 1);
//System.out.println("left is: " + left);
//System.out.println("clause is: " + clause);
//System.out.println("right is: " + right);
// Determine left and right halves of parents
final List<String[]> parents = determineParents(left, right);
// System.out.println("Parents:\n");
// for (final String[] parent : parents)
// System.out.println(parent[0] + "?" + parent[1] + "\n");
final List<String> choices = extractChoices(clause);
final List<String> inclusions = new ArrayList<String>();
final List<String> exclusions = new ArrayList<String>();
//final List<String> enumerations = new ArrayList<String>();
int enumeration = 0;
for (int c = choices.size() - 1; c >= 0; c--)
{
final String choice = choices.get(c);
//System.out.println("choice is: " + choice);
if
(
choice.length() > 3 && choice.charAt(0) == '['
&&
choice.charAt(1) == '+' && choice.charAt(choice.length() - 1) == ']'
)
{
// Is an inclusion
inclusions.add(choice.substring(2, choice.length() - 1).trim());
choices.remove(c);
}
else if
(
choice.length() > 3 && choice.charAt(0) == '['
&&
choice.charAt(1) == '-' && choice.charAt(choice.length() - 1) == ']'
)
{
// Is an exclusion
exclusions.add(choice.substring(2, choice.length() - 1).trim());
choices.remove(c);
}
else if
(
choice.length() >= 1 && choice.charAt(0) == '#'
||
choice.length() >= 3 && choice.charAt(0) == '['
&&
choice.charAt(1) == '#' && choice.charAt(choice.length() - 1) == ']'
)
{
// Is an enumeration
//enumerations.add(choice.substring(1, choice.length() - 1).trim());
enumeration = numHashes(choice);
//System.out.println("Enumeration has " + enumeration + " hashes...");
choices.remove(c);
}
}
if (enumeration > 0)
{
// Enumerate on parents
final String[] parent = parents.get(enumeration - 1);
//System.out.println("Enumerating on parent " + enumeration + ": " + parent[0] + "?" + parent[1]);
enumerateMatches(left, right, parent, ludMap, queue, completion.score());
enumerateMatches(left, right, parent, defMap, queue, completion.score());
}
else
{
// Handle choices as usual
for (int n = 0; n < choices.size(); n++)
{
final String choice = choices.get(n);
if (!exclusions.isEmpty())
{
// Check whether this choice contains excluded text
boolean found = false;
for (final String exclusion : exclusions)
if (choice.contains(exclusion))
{
found = true;
break;
}
if (found)
continue; // excluded text is present
}
if (!inclusions.isEmpty())
{
// Check that this choice contains included text
boolean found = false;
for (final String inclusion : inclusions)
if (choice.contains(inclusion))
{
found = true;
break;
}
if (!found)
continue; // included text is not present
}
final String str = raw.substring(0, from) + choice + raw.substring(to + 1);
final Completion newCompletion = new Completion(str);
// System.out.println("\n**********************************************************");
// System.out.println("completion " + n + "/" + choices.size() + " is:\n" + completion);
queue.add(newCompletion);
}
}
}
//-------------------------------------------------------------------------
/**
* Creates list of completions irrespective of previous completions.
* @param raw Partial raw game description.
* @param maxCompletions Maximum number of completions to make (default is 1, e.g. for Travis tests).
* @param report Report log for warnings and errors.
* @return List of completed (raw) game descriptions ready for expansion and parsing.
*/
public static List<Completion> completeSampled(final String raw, final int maxCompletions, final Report report)
{
// System.out.println("\nCompleter.complete(): Completing at most " + maxCompletions + " descriptions...");
final List<Completion> completions = new ArrayList<Completion>();
// Create list of alternative Descriptions, as each will need to be expanded
final Map<String, String> ludMap = getAllLudContents();
final Map<String, String> defMap = getAllDefContents();
for (int n = 0; n < maxCompletions; n++)
{
Completion comp = new Completion(new String(raw));
while (needsCompleting(comp.raw()))
comp = nextCompletionSampled(comp, ludMap, defMap, report);
completions.add(comp);
}
// System.out.println("\nList of completions:");
// for (final Completion comp : completions)
// System.out.println(comp.raw());
return completions;
}
//-------------------------------------------------------------------------
/**
* Process next completion and add results to queue.
* Solves the next completion independently by sampling from candidates.
* @param report
*/
public static Completion nextCompletionSampled
(
final Completion completion,
final Map<String, String> ludMap, final Map<String, String> defMap,
final Report report
)
{
// System.out.println("\nCompleting next completion for raw string:\n" + completion.raw());
final Random rng = new Random();
final List<Completion> completions = new ArrayList<Completion>();
// Find opening and closing bracket locations
final String raw = Expander.removeComments(completion.raw());
final int from = raw.indexOf("[");
final int to = StringRoutines.matchingBracketAt(raw, from);
// Get reconstruction clause (substring within square brackets)
final String left = raw.substring(0, from);
final String clause = raw.substring(from + 1, to);
final String right = raw.substring(to + 1);
//System.out.println("left is: " + left);
//System.out.println("clause is: " + clause);
//System.out.println("right is: " + right);
// Determine left and right halves of parents
final List<String[]> parents = determineParents(left, right);
// System.out.println("Parents:\n");
// for (final String[] parent : parents)
// System.out.println(parent[0] + "?" + parent[1] + "\n");
final List<String> choices = extractChoices(clause);
final List<String> inclusions = new ArrayList<String>();
final List<String> exclusions = new ArrayList<String>();
//final List<String> enumerations = new ArrayList<String>();
int enumeration = 0;
for (int c = choices.size() - 1; c >= 0; c--)
{
final String choice = choices.get(c);
//System.out.println("choice is: " + choice);
if
(
choice.length() > 3 && choice.charAt(0) == '['
&&
choice.charAt(1) == '+' && choice.charAt(choice.length() - 1) == ']'
)
{
// Is an inclusion
inclusions.add(choice.substring(2, choice.length() - 1).trim());
choices.remove(c);
}
else if
(
choice.length() > 3 && choice.charAt(0) == '['
&&
choice.charAt(1) == '-' && choice.charAt(choice.length() - 1) == ']'
)
{
// Is an exclusion
exclusions.add(choice.substring(2, choice.length() - 1).trim());
choices.remove(c);
}
else if
(
choice.length() >= 1 && choice.charAt(0) == '#'
||
choice.length() >= 3 && choice.charAt(0) == '['
&&
choice.charAt(1) == '#' && choice.charAt(choice.length() - 1) == ']'
)
{
// Is an enumeration
//enumerations.add(choice.substring(1, choice.length() - 1).trim());
enumeration = numHashes(choice);
//System.out.println("Enumeration has " + enumeration + " hashes...");
choices.remove(c);
}
}
if (enumeration > 0)
{
// Enumerate on parents
final String[] parent = parents.get(enumeration - 1);
// System.out.println("\nEnumerating on parent " + enumeration + ": \"" + parent[0] + "\" + ? + \"" + parent[1] + "\"");
enumerateMatches(left, right, parent, ludMap, completions, completion.score());
enumerateMatches(left, right, parent, defMap, completions, completion.score());
}
else
{
// Handle choices as usual
for (int n = 0; n < choices.size(); n++)
{
final String choice = choices.get(n);
if (!exclusions.isEmpty())
{
// Check whether this choice contains excluded text
boolean found = false;
for (final String exclusion : exclusions)
if (choice.contains(exclusion))
{
found = true;
break;
}
if (found)
continue; // excluded text is present
}
if (!inclusions.isEmpty())
{
// Check that this choice contains included text
boolean found = false;
for (final String inclusion : inclusions)
if (choice.contains(inclusion))
{
found = true;
break;
}
if (!found)
continue; // included text is not present
}
final String str = raw.substring(0, from) + choice + raw.substring(to + 1);
final Completion newCompletion = new Completion(str);
// System.out.println("\n**********************************************************");
// System.out.println("completion " + n + "/" + choices.size() + " is:\n" + completion);
//queue.add(newCompletion);
completions.add(newCompletion);
}
}
if (completions.isEmpty())
{
// No valid completions for this completion point
if (report != null)
report.addError("No completions for: " + raw);
return null;
// **
// ** TODO: Choose preferred completion based on context.
// **
// ** TODO: Maybe use UCB to balance reward with novelty, i.e. prefer
// ** high scoring candidates but not the same ones every time,
// ** also try low scoring ones occasionally.
// **
}
return completions.get(rng.nextInt(completions.size()));
}
//-------------------------------------------------------------------------
/**
* Enumerate all parent matches in the specified map.
* @param parent
* @param map
* @param queue
*/
private static void enumerateMatches
(
final String left, final String right, final String[] parent,
final Map<String, String> map, final List<Completion> queue,
final double confidence
)
{
for (Map.Entry<String, String> entry : map.entrySet())
{
final String otherDescription = entry.getValue();
final String candidate = new String(otherDescription);
// **
// ** TODO: Determine distance between map entry and this completion
// **
final double distance = 0.1; // dummy value for testing
final int l = candidate.indexOf(parent[0]);
if (l < 0)
continue; // not a match
String secondPart = candidate.substring(l + parent[0].length()); //.trim();
// System.out.println("\notherDescription is: " + otherDescription);
// System.out.println("parent[0] is: " + parent[0]);
// System.out.println("parent[1] is: " + parent[1]);
// System.out.println("secondPart is: " + secondPart);
// System.out.println("left is: " + left);
// System.out.println("right is: " + right);
// final int r = secondPart.indexOf(parent[1]);
final int r = (StringRoutines.isBracket(secondPart.charAt(0)))
? StringRoutines.matchingBracketAt(secondPart, 0)
: secondPart.indexOf(parent[1]) - 1;
if (r >= 0)
{
// Is a match
//final String match = mapString.substring(l, l + parent[0].length() + r + parent[1].length());
final String match = secondPart.substring(0, r + 1); //l, l + parent[0].length() + r + parent[1].length());
//System.out.println("match is: " + match);
// final String str =
// left.substring(0, left.length() - parent[0].length())
// +
// match
// +
// right.substring(parent[1].length());
//final String str = left + " " + match + " " + right;
String str = left + match + right;
// Eric: I COMMENTED THIS, BECAUSE this code is making an infinite loop on some cases and break Travis.
//str = addLocalDefines(str, otherDescription);
final Completion completion = new Completion(str);
//System.out.println("completion is:\n" + completion.raw());
if (!queue.contains(completion))
{
//System.out.println("Adding completion:\n" + completion.raw());
completion.setScore(confidence * (1 - distance));
queue.add(completion);
}
}
}
}
//-------------------------------------------------------------------------
/**
* @return Completed string with all necessary local defines added.
*/
static String addLocalDefines(final String current, final String otherDescription)
{
// Make a list of local defines in the current description
final List<Define> localDefinesCurrent = new ArrayList<Define>();
Expander.extractDefines(current, localDefinesCurrent, null);
// System.out.println("Local defines (current):");
// for (final Define def : localDefinesCurrent)
// System.out.println("-- " + def.formatted());
// Make a list of local defines in the other description
final List<Define> localDefinesOther = new ArrayList<Define>();
Expander.extractDefines(otherDescription, localDefinesOther, null);
// System.out.println("Local defines (other):");
// for (final Define def : localDefinesOther)
// System.out.println("-- " + def.formatted());
// Determine which defines from the other description are used in the current description
final BitSet used = new BitSet();
for (int n = 0; n < localDefinesOther.size(); n++)
if (current.contains(localDefinesOther.get(n).tag()))
used.set(n);
// Turn off the ones already present in the current description
for (int n = 0; n < localDefinesCurrent.size(); n++)
{
if (!used.get(n))
continue; // not used
final Define localDefineCurrent = localDefinesCurrent.get(n);
boolean found = false;
for (int o = 0; o < localDefinesOther.size() && !found; o++)
{
final Define localDefineOther = localDefinesOther.get(o);
if (localDefineOther.tag().equals(localDefineCurrent.tag()))
found = true;
}
if (found)
used.set(n, false); // turn it off again
}
// Prepend used defines to the current string
String result = new String(current);
for (int n = used.nextSetBit(0); n >= 0; n = used.nextSetBit(n + 1))
result = localDefinesOther.get(n).formatted() + result;
return result;
}
//-------------------------------------------------------------------------
/**
* @return Number of hash characters '#' in string.
*/
private static int numHashes(final String str)
{
int numHashes = 0;
for (int c = 0; c < str.length(); c++)
if (str.charAt(c) == '#')
numHashes++;
return numHashes;
}
//-------------------------------------------------------------------------
/**
* @return List of successively nested parents based on left and right substrings.
*/
private static final List<String[]> determineParents
(
final String left, final String right
)
{
final List<String[]> parents = new ArrayList<String[]>();
// Step backwards to previous bracket on left side
int l = left.length() - 1;
int r = 0;
boolean lZero = false;
boolean rEnd = false;
for (int p = 0; p < MAX_PARENTS; p++)
{
// Step backwards to previous "("
while (l > 0 && left.charAt(l) != '(' && left.charAt(l) != '{')
{
// Step past embedded clauses
if (left.charAt(l) == ')' || left.charAt(l) == '}')
{
int depth = 1;
while (l >= 0 && depth > 0)
{
l--;
if (l < 0)
break;
if (left.charAt(l) == ')' || left.charAt(l) == '}')
depth++;
else if (left.charAt(l) == '(' || left.charAt(l) == '{')
depth--;
}
}
else
{
l--;
}
}
if (l > 0)
l--;
if (l == 0)
{
if (lZero)
break;
lZero = true;
}
if (l < 0)
break;
// Step forwards to next bracket on right side
boolean curly = left.charAt(l + 1) == '{';
while
(
r < right.length()
&&
(
!curly && right.charAt(r) != ')'
||
curly && right.charAt(r) != '}'
)
)
{
// Step past embedded clauses
if (right.charAt(r) == '(' || right.charAt(r) == '{')
{
int depth = 1;
while (r < right.length() && depth > 0)
{
r++;
if (r >= right.length())
break;
if (right.charAt(r) == '(' || right.charAt(r) == '{')
depth++;
else if (right.charAt(r) == ')' || right.charAt(r) == '}')
depth--;
}
}
else
{
r++;
}
}
if (r < right.length() - 1)
r++;
if (r == right.length() - 1)
{
if (rEnd)
break;
rEnd = true;
}
if (r >= right.length())
break;
// Store the two halves of the parent
final String[] parent = new String[2];
parent[0] = left.substring(l); //.trim();
parent[1] = right.substring(0, r); //.trim();
// Strip leading spaces from parent[0]
while (parent[0].length() > 0 && parent[0].charAt(0) == ' ')
parent[0] = parent[0].substring(1);
//System.out.println("Parent " + p + " is " + parent[0] + "?" + parent[1]);
parents.add(parent);
}
return parents;
}
//-------------------------------------------------------------------------
/**
* Extract completion choices from reconstruction clause.
* @param clause
* @return
*/
static List<String> extractChoices(final String clause)
{
final List<String> choices = new ArrayList<String>();
if (clause.length() >= 1 && clause.charAt(0) == '#')
{
// Is an enumeration, just return as is
choices.add(clause);
return choices;
}
final StringBuilder sb = new StringBuilder();
int depth = 0;
for (int c = 0; c < clause.length(); c++)
{
final char ch = clause.charAt(c);
if (depth == 0 && (c >= clause.length() - 1 || ch == CHOICE_DIVIDER_CHAR))
{
// Store this choice and reset sb
final String choice = sb.toString().trim();
// System.out.println("extractChoices choice is: " + choice);
if (choice.contains(".."))
{
// Handle range
final List<String> rangeChoices = expandRanges(new String(choice), null);
if (!rangeChoices.isEmpty() && !rangeChoices.get(0).contains(".."))
{
// Is a number range
//System.out.println(rangeChoices.size() + " range choices:" + rangeChoices);
choices.addAll(rangeChoices);
}
else
{
// Check for site ranges
final List<String> siteChoices = expandSiteRanges(new String(choice), null);
if (!siteChoices.isEmpty())
choices.addAll(siteChoices);
}
}
else
{
choices.add(choice);
}
// Reset to accumulate next choice
sb.setLength(0);
}
else
{
if (ch == '[')
depth++;
else if (ch == ']')
depth--;
sb.append(ch);
}
}
return choices;
}
//-------------------------------------------------------------------------
/**
* @param strIn
* @return Game description with all number range occurrences expanded.
*/
private static List<String> expandRanges
(
final String strIn,
final Report report
)
{
final List<String> choices = new ArrayList<String>();
if (!strIn.contains(".."))
return choices; // nothing to do
String str = new String(strIn);
int ref = 1;
while (ref < str.length() - 2)
{
if
(
str.charAt(ref) == '.' && str.charAt(ref+1) == '.'
&&
Character.isDigit(str.charAt(ref-1))
&&
Character.isDigit(str.charAt(ref+2))
)
{
// Is a range: expand it
int c = ref - 1;
while (c >= 0 && Character.isDigit(str.charAt(c)))
c--;
c++;
final String strM = str.substring(c, ref);
final int m = Integer.parseInt(strM);
c = ref + 2;
while (c < str.length() && Character.isDigit(str.charAt(c)))
c++;
final String strN = str.substring(ref+2, c);
final int n = Integer.parseInt(strN);
if (Math.abs(n - m) > MAX_RANGE)
{
if (report == null)
{
System.out.println("** Range exceeded maximum of " + MAX_RANGE + ".");
}
else
{
report.addError("Range exceeded maximum of " + MAX_RANGE + ".");
return null;
}
}
// Generate the expanded range substring
String sub = " ";
final int inc = (m <= n) ? 1 : -1;
for (int step = m; step != n; step += inc)
{
if (step == m || step == n)
continue; // don't include end points
sub += step + " ";
}
str = str.substring(0, ref) + sub + str.substring(ref+2);
ref += sub.length();
}
ref++;
}
final String[] subs = str.split(" ");
for (final String sub : subs)
choices.add(sub);
return choices;
}
/**
* @param strIn
* @return Game description with all site range occurrences expanded.
*/
private static List<String> expandSiteRanges
(
final String strIn,
final Report report
)
{
final List<String> choices = new ArrayList<String>();
//System.out.println("** Warning: Completer: Site ranges not expanded yet.");
//return choices;
if (!strIn.contains(".."))
return choices; // nothing to do
String str = new String(strIn);
int ref = 1;
while (ref < str.length() - 2)
{
if
(
str.charAt(ref) == '.' && str.charAt(ref+1) == '.'
&&
str.charAt(ref-1) == '"' && str.charAt(ref+2) == '"'
)
{
// Must be a site range
int c = ref - 2;
while (c >= 0 && str.charAt(c) != '"')
c--;
final String strC = str.substring(c+1, ref-1);
// System.out.println("strC: " + strC);
int d = ref + 3;
while (d < str.length() && str.charAt(d) != '"')
d++;
d++;
final String strD = str.substring(ref+3, d-1);
// System.out.println("strD: " + strD);
// System.out.println("Range: " + str.substring(c, d));
if (strC.length() < 2 || !isLetter(strC.charAt(0)))
{
if (report != null)
report.addError("Bad 'from' coordinate in site range: " + str.substring(c, d));
return null;
}
final int fromChar = Character.toUpperCase(strC.charAt(0)) - 'A';
if (strD.length() < 2 || !isLetter(strD.charAt(0)))
{
if (report != null)
report.addError("Bad 'to' coordinate in site range: " + str.substring(c, d));
return null;
}
final int toChar = Character.toUpperCase(strD.charAt(0)) - 'A';
// System.out.println("fromChar=" + fromChar + ", toChar=" + toChar + ".");
final int fromNum = Integer.parseInt(strC.substring(1));
final int toNum = Integer.parseInt(strD.substring(1));
// System.out.println("fromNum=" + fromNum + ", toNum=" + toNum + ".");
// Generate the expanded range substring
String sub = "";
for (int m = fromChar; m < toChar + 1; m++)
for (int n = fromNum; n < toNum + 1; n++)
sub += "\"" + (char)('A' + m) + (n) + "\" ";
str = str.substring(0, c) + sub.trim() + str.substring(d);
ref += sub.length();
}
ref++;
}
//System.out.println("str is: " + str);
final String[] subs = str.split(" ");
for (final String sub : subs)
choices.add(sub);
return choices;
}
public static boolean isLetter(final char ch)
{
return ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z';
}
//-------------------------------------------------------------------------
// Ludeme loader code from Matthew
/**
* @return Names and contents of all files within the lud/board path.
*/
public static Map<String, String> getAllLudContents()
{
return getAllDirectoryContents("../Common/res/lud/board/");
}
/**
* @return Names and contents of all files within the define path.
*/
public static Map<String, String> getAllDefContents()
{
return getAllDirectoryContents("../Common/res/def/");
}
/**
* @return Names and contents of all files within the specific directory path.
*/
public static Map<String, String> getAllDirectoryContents(final String dir)
{
final File startFolder = new File(dir);
final List<File> gameDirs = new ArrayList<>();
gameDirs.add(startFolder);
final Map<String, String> fileContents = new HashMap<>();
for (int i = 0; i < gameDirs.size(); ++i)
{
final File gameDir = gameDirs.get(i);
for (final File fileEntry : gameDir.listFiles())
{
if (fileEntry.isDirectory())
{
gameDirs.add(fileEntry);
}
else
{
try(BufferedReader br = new BufferedReader(new FileReader(fileEntry)))
{
final StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null)
{
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
// Strip out formatting so that completion string matching it more robust
everything = Expander.cleanUp(everything, null);
fileContents.put(fileEntry.getName(), everything);
}
catch (final FileNotFoundException e)
{
e.printStackTrace();
}
catch (final IOException e)
{
e.printStackTrace();
}
}
}
}
return fileContents;
}
//-------------------------------------------------------------------------
/**
* Save reconstruction to file.
* @param path Path to save output file (will use default /Common/res/out/recons/ if null).
* @param name Output file name for reconstruction.
* @throws IOException
*/
public static void saveCompletion
(
final String path, final String name, final Completion completion
) throws IOException
{
final String safePath = (path != null) ? path : "../Common/res/out/recons/";
// **
// ** TODO: Need to check if this path exists! If not, then try to make it.
// **
//final String scoreString = String.format("%.3f", Double.valueOf(completion.score()));
//final String outFileName = safePath + name + "-" + index + "-" + scoreString + ".lud";
final String outFileName = safePath + name + ".lud";
// Prepare the output file
final File file = new File(outFileName);
if (!file.exists())
file.createNewFile();
try
(
final PrintWriter writer =
new PrintWriter
(
new BufferedWriter(new FileWriter(outFileName, false))
)
)
{
writer.write(completion.raw());
}
}
//-------------------------------------------------------------------------
}
| 30,071 | 26.973953 | 122 |
java
|
Ludii
|
Ludii-master/Language/src/completer/Completion.java
|
package completer;
import java.util.ArrayList;
import java.util.List;
import gnu.trove.list.array.TIntArrayList;
/**
* Record of a reconstruction completion, which will be a raw *.lud description.
* @author cambolbro and Eric.Piette
*/
public class Completion
{
private String raw; // completed game description
private double score = 0; // confidence in enumeration (0..1)
private double culturalScore = 0; // (0..1)
private double conceptualScore = 0; // (0..1)
private double geographicalScore = 0; // (0..1)
private TIntArrayList idsUsed = new TIntArrayList(); // The ruleset ids used to make the completion.
private List<TIntArrayList> otherIdsUSed = new ArrayList<TIntArrayList>(); // The other possible combinations of rulesets used to obtain the same completion.
//-------------------------------------------------------------------------
public Completion(final String raw)
{
this.raw = raw;
}
//-------------------------------------------------------------------------
public String raw()
{
return raw;
}
public void setRaw(final String raw)
{
this.raw = raw;
}
public double score()
{
return score;
}
public void setScore(final double value)
{
score = value;
}
public double culturalScore()
{
return culturalScore;
}
public void setCulturalScore(final double value)
{
culturalScore = value;
}
public double geographicalScore()
{
return geographicalScore;
}
public void setGeographicalScore(final double value)
{
geographicalScore = value;
}
public double conceptualScore()
{
return conceptualScore;
}
public void setConceptualScore(final double value)
{
conceptualScore = value;
}
public TIntArrayList idsUsed()
{
return idsUsed;
}
public void setIdsUsed(final TIntArrayList ids)
{
idsUsed = new TIntArrayList(ids);
}
public void addId(final int id)
{
idsUsed.add(id);
}
public List<TIntArrayList> otherIdsUsed()
{
return otherIdsUSed;
}
public void addOtherIds(final TIntArrayList ids)
{
otherIdsUSed.add(ids);
}
//-------------------------------------------------------------------------
@Override
public String toString()
{
return raw;
}
}
| 2,198 | 18.121739 | 158 |
java
|
Ludii
|
Ludii-master/Language/src/completer/TestCompleter.java
|
package completer;
//import static org.junit.Assert.*;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
//import org.junit.Test;
//import main.grammar.Report;
//import parser.Completer;
/**
* Test various reconstruction routines.
* @author cambolbro
*/
public class TestCompleter
{
//-------------------------------------------------------------------------
// @Test
// public void test()
// {
// testSaving();
// testLoadLuds();
// testCompletion();
// }
//-------------------------------------------------------------------------
/**
* From FileHandling.
* @param filePath
* @return Text contents from file.
* @throws IOException
* @throws FileNotFoundException
*/
public static String loadTextContentsFromFile(final String filePath) throws FileNotFoundException, IOException
{
// Load the string from file
final StringBuilder sb = new StringBuilder();
String line = null;
try
(
final InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), StandardCharsets.UTF_8);
final BufferedReader bufferedReader = new BufferedReader(isr)
)
{
while ((line = bufferedReader.readLine()) != null)
sb.append(line + "\n");
}
return sb.toString();
}
//-------------------------------------------------------------------------
// void testSaving()
// {
// try
// {
// Completer.saveReconstruction("Test", "(test ...)");
// }
// catch (IOException e)
// {
// e.printStackTrace();
// }
// }
//-------------------------------------------------------------------------
static void testLoadLuds()
{
final Map<String, String> luds = Completer.getAllLudContents();
final Map<String, String> defs = Completer.getAllDefContents();
System.out.println(luds.size() + " luds loaded, " + defs.size() + " defs loaded.");
}
//-------------------------------------------------------------------------
static void testCompletion()
{
testCompletion(null, "TestReconOneClause.lud");
testCompletion(null, "TestReconTwoClauses.lud");
testCompletion(null, "TestReconNested.lud");
testCompletion(null, "TestReconRange.lud");
testCompletion(null, "TestReconRanges.lud");
testCompletion(null, "TestReconRangeSite.lud");
testCompletion(null, "TestReconInclude.lud");
testCompletion(null, "TestReconExclude.lud");
testCompletion(null, "TestReconEnumeration1.lud");
testCompletion(null, "TestReconEnumeration2.lud");
}
/**
* @param outFilePath Path to save output file (will use default /Common/res/out/recons/ if null).
* @param fileName File name.
*/
static void testCompletion(final String outFilePath, final String fileName)
{
//final String fileName = "TestReconA.lud";
final String filePath = "../Common/res/lud/test/recon/" + fileName;
System.out.println("\n####################################################");
System.out.println("\nTesting completion of " + filePath);
String str = "";
try
{
str = loadTextContentsFromFile(filePath);
System.out.println("desc:\n" + str);
System.out.println("File needs completing: " + Completer.needsCompleting(str));
//final Report report = new Report();
//final List<Completion> completions = Completer.completeExhaustive(str, 3, null); // save all completions
final List<Completion> completions = Completer.completeSampled(str, 3, null); // only save first completion for each file
for (int n = 0; n < completions.size(); n++)
{
final Completion completion = completions.get(n);
// Don't add ".lud" suffix, that is added by completer
final int suffixAt = fileName.indexOf(".lud");
final String outFileName = fileName.substring(0, suffixAt) + "-" + n;
try
{
Completer.saveCompletion(outFilePath, outFileName, completion);
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
catch (final FileNotFoundException ex)
{
System.out.println("Unable to open file '" + fileName + "'");
}
catch (final IOException ex)
{
System.out.println("Error reading file '" + fileName + "'");
}
//final Map<String, String> luds = Completer.getAllLudContents();
//final Map<String, String> defs = Completer.getAllDefContents();
//System.out.println(luds.size() + " luds loaded, " + defs.size() + " defs loaded.");
}
//-------------------------------------------------------------------------
public static void main(String[] args)
{
TestCompleter.testLoadLuds();
TestCompleter.testCompletion();
}
}
| 4,706 | 27.527273 | 125 |
java
|
Ludii
|
Ludii-master/Language/src/grammar/ClassEnumerator.java
|
package grammar;
// From: https://github.com/ddopson/java-class-enumerator
// Reference: https://stackoverflow.com/questions/10119956/getting-class-by-its-name
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
//-----------------------------------------------------------------------------
/**
* Routines for enumerating classes.
* @author Dennis Soemers and cambolbro
*/
public class ClassEnumerator
{
// private static void log(String msg)
// {
// System.out.println("ClassDiscovery: " + msg);
// }
private static Class<?> loadClass(String className)
{
try
{
return Class.forName(className);
}
catch (final ClassNotFoundException e) {
throw new RuntimeException("Unexpected ClassNotFoundException loading class '" + className + "'");
}
}
/**
* Given a package name and a directory returns all classes within that directory
* @param directory
* @param pkgname
* @return Classes within Directory with package name
*/
public static List<Class<?>> processDirectory(File directory, String pkgname) {
final ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
// log("Reading Directory '" + directory + "'");
// Get the list of the files contained in the package
final String[] files = directory.list();
for (int i = 0; i < files.length; i++) {
final String fileName = files[i];
String className = null;
// we are only interested in .class files
if (fileName.endsWith(".class")) {
// removes the .class extension
className = pkgname + '.' + fileName.substring(0, fileName.length() - 6);
}
// log("FileName '" + fileName + "' => class '" + className + "'");
if (className != null) {
classes.add(loadClass(className));
}
//If the file is a directory recursively class this method.
final File subdir = new File(directory, fileName);
if (subdir.isDirectory()) {
classes.addAll(processDirectory(subdir, pkgname + '.' + fileName));
}
}
return classes;
}
/**
* Given a jar file and a package name returns all classes within jar file.
*
* @param jarFile
* @param pkgname
* @return The list of the classes.
*/
public static List<Class<?>> processJarfile(final JarFile jarFile, final String pkgname)
{
final List<Class<?>> classes = new ArrayList<Class<?>>();
//Turn package name to relative path to jar file
final String relPath = pkgname.replace('.', '/');
try
{
// Get contents of jar file and iterate through them
final Enumeration<JarEntry> entries = jarFile.entries();
while(entries.hasMoreElements()) {
final JarEntry entry = entries.nextElement();
//Get content name from jar file
final String entryName = entry.getName();
String className = null;
// If content is a class save class name.
if
(
entryName.endsWith(".class")
&&
entryName.startsWith(relPath)
&&
entryName.length() > (relPath.length() + "/".length())
)
{
className = entryName.replace('/', '.').replace('\\', '.');
className = className.substring(0, className.length() - ".class".length());
}
// log("JarEntry '" + entryName + "' => class '" + className + "'");
//If content is a class add class to List
if (className != null) {
classes.add(loadClass(className));
}
}
jarFile.close();
}
catch (final IOException e)
{
throw new RuntimeException("Unexpected IOException reading JAR File '" + jarFile.getName() + "'", e);
}
return classes;
}
//-------------------------------------------------------------------------
/**
* Return all classes contained in a given package.
* @param pkg
* @return The list of the classes.
*/
public static List<Class<?>> getClassesForPackage(final Package pkg)
{
final ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
//Get name of package and turn it to a relative path
final String pkgname = pkg.getName();
final String relPath = pkgname.replace('.', '/');
// **
// ** The following code fails when looking for path in web archive.
// **
//final URL url = ClassLoader.getSystemClassLoader().getResource(relPath);
final URL url = ClassEnumerator.class.getClassLoader().getResource(relPath);
//System.out.println("pkg=" + pkg + ", relPath=" + relPath + ", url=" + url);
// If the resource is a jar get all classes from jar
if (url.getPath().contains(".jar"))
{
try
(
final JarFile jarFile = new JarFile
(
new File(ClassEnumerator.class.getProtectionDomain().getCodeSource().getLocation().toURI()))
)
{
classes.addAll(processJarfile(jarFile, pkgname));
}
catch (final IOException | URISyntaxException e)
{
throw new RuntimeException("Unexpected problem with JAR file for: " + relPath);
}
}
else
{
try
{
classes.addAll(processDirectory(new File(URLDecoder.decode(url.getPath(), "UTF-8")), pkgname));
}
catch (final UnsupportedEncodingException e)
{
e.printStackTrace();
}
}
return classes;
}
}
| 5,340 | 26.389744 | 104 |
java
|
Ludii
|
Ludii-master/Language/src/grammar/ClassEnumeratorFindAll.java
|
package grammar;
// From: https://github.com/ddopson/java-class-enumerator
// Reference: https://stackoverflow.com/questions/10119956/getting-class-by-its-name
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
//-----------------------------------------------------------------------------
/**
*
*/
public class ClassEnumeratorFindAll
{
// private static void log(String msg)
// {
// System.out.println("ClassEnumeratorFindAll: " + msg);
// }
private static Class<?> loadClass(String className) {
try {
return Class.forName(className);
} catch (final ClassNotFoundException e) {
throw new RuntimeException("Unexpected ClassNotFoundException loading class '" + className + "'");
}
}
/**
* Given a directory returns all classes within that directory
*
* @param directory
* @return Classes within Directory
*/
public static List<Class<?>> processDirectory(File directory) {
final ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
// log("Reading Directory '" + directory + "'");
try {
// Get the list of the files contained in the package
final String[] files = directory.list();
for (int i = 0; i < files.length; i++) {
final String fileName = files[i];
String className = null;
// we are only interested in .class files
if (fileName.endsWith(".class")) {
// removes the .class extension
className = fileName.substring(0, fileName.length() - 6);
}
// log("FileName '" + fileName + "' => class '" + className + "'");
if (className != null) {
classes.add(loadClass(className));
}
// If the file is a directory recursively find class.
final File subdir = new File(directory, fileName);
if (subdir.isDirectory()) {
classes.addAll(processDirectory(subdir));
}
// if file is a jar file
if (fileName.endsWith(".jar")) {
classes.addAll(processJarfile(directory.getAbsolutePath() + "/" + fileName));
}
}
} catch (final Exception e) {
e.printStackTrace();
}
return classes;
}
/**
* Given a jar file's URL returns all classes within jar file.
*
* @param jarPath The path of the Jar.
* @return The list of classes.
*/
public static List<Class<?>> processJarfile(String jarPath)
{
final List<Class<?>> classes = new ArrayList<Class<?>>();
try (JarFile jarFile = new JarFile(jarPath))
{
// Get contents of jar file and iterate through them
final Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
final JarEntry entry = entries.nextElement();
// Get content name from jar file
final String entryName = entry.getName();
String className = null;
// If content is a class save class name.
if (entryName.endsWith(".class"))
{
className = entryName.replace('/', '.').replace('\\', '.');
className = className.substring(0, className.length() - ".class".length());
}
// log("JarEntry '" + entryName + "' => class '" + className + "'");
// If content is a class add class to List
if (className != null) {
classes.add(loadClass(className));
continue;
}
// If jar contains another jar then iterate through it
if (entryName.endsWith(".jar")) {
classes.addAll(processJarfile(entryName));
continue;
}
// If content is a directory
final File subdir = new File(entryName);
if (subdir.isDirectory()) {
classes.addAll(processDirectory(subdir));
}
}
jarFile.close();
}
catch (final IOException e)
{
throw new RuntimeException("Unexpected IOException reading JAR File '" + jarPath + "'", e);
}
return classes;
}
}
| 3,803 | 25.978723 | 101 |
java
|
Ludii
|
Ludii-master/Language/src/grammar/Grammar.java
|
package grammar;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import annotations.Alias;
import main.Constants;
import main.FileHandling;
import main.StringRoutines;
import main.grammar.Clause;
import main.grammar.ClauseArg;
import main.grammar.GrammarRule;
import main.grammar.LudemeInfo;
import main.grammar.PackageInfo;
import main.grammar.Symbol;
import main.grammar.Symbol.LudemeType;
import main.grammar.ebnf.EBNF;
//-----------------------------------------------------------------------------
/**
* Ludii class grammar generator.
*
* @author cambolbro
*/
public class Grammar
{
/** List of symbols. */
private final List<Symbol> symbols = new ArrayList<Symbol>();
/** Hash map for accessing symbols directly by name (might be multiples). */
private final Map<String, List<Symbol>> symbolsByName = new HashMap<String, List<Symbol>>();
/** Hash map for identifying symbols by partial keyword (most will have multiples). */
private final Map<String, List<Symbol>> symbolsByPartialKeyword = new HashMap<String, List<Symbol>>();
/** List of rules. */
private final List<GrammarRule> rules = new ArrayList<GrammarRule>();
/** List of rule packages. */
private final List<PackageInfo> packages = new ArrayList<PackageInfo>();
/** Order in which packages are to be printed. */
private final List<PackageInfo> packageOrder = new ArrayList<PackageInfo>();
private Symbol rootGameSymbol = null;
private Symbol rootMetadataSymbol = null;
private EBNF ebnf = null;
//-------------------------------------------------------------------------
/** Primitive symbols with notional package names. */
public static final String[][] Primitives =
{
{ "int", "game.functions.ints" },
{ "boolean", "game.functions.booleans" },
{ "float", "game.functions.floats" },
};
/** Predefined symbols (known data types) with notional and actual package names, and keyword. */
public static final String[][] Predefined =
{
{ "java.lang.Integer", "game.functions.ints", "java.lang", "int" },
{ "java.lang.Boolean", "game.functions.booleans", "java.lang", "boolean" },
{ "java.lang.Float", "game.functions.floats", "java.lang", "float" },
{ "java.lang.String", "game.types", "java.lang", "string" },
};
/** Function names and associated constants. */
private final String[][] Functions =
{
// Function name Arg replacement Listed symbols (if any)
{ "IntFunction", "int", },
{ "IntConstant", "int", },
{ "BooleanFunction", "boolean", },
{ "BooleanConstant", "boolean", },
{ "FloatFunction", "float", },
{ "FloatConstant", "float", },
{ "IntArrayFunction", "ints", },
{ "IntArrayConstant", "ints", },
{ "RegionFunction", "sites", },
{ "RegionConstant", "sites", },
//{ "Region", "sites", },
{ "RangeFunction", "range", },
{ "RangeConstant", "range", },
{ "DirectionsFunction", "directions", },
{ "DirectionsConstant", "directions", },
{ "GraphFunction", "graph", },
{ "GraphConstant", "graph", },
//{ "GraphFunction", "tiling", },
//{ "GraphConstant", "tiling", },
{ "DimFunction", "dim", },
{ "DimConstant", "dim", },
};
/** Application constants. */
public final static String[][] ApplicationConstants =
{
// Constant name, return type, notional package, value
{ "Off", "int", "global", ("" + Constants.OFF) },
{ "End", "int", "global", ("" + Constants.END) },
{ "Undefined", "int", "global", ("" + Constants.UNDEFINED) },
{ "Infinity", "int", "global", ("" + Constants.INFINITY) },
// { "Unused", "int", "global", ("" + Constants.UNUSED) },
// { "Nobody", "int", "global", ("" + Constants.NOBODY) },
// { "NoPiece", "int", "global", ("" + Constants.NO_PIECE) },
// { "Repeat", "int", "global", ("" + Constants.REPEAT) },
};
//-------------------------------------------------------------------------
private static volatile Grammar singleton = null;
//-------------------------------------------------------------------------
private Grammar()
{
//final long startAt = System.nanoTime();
generate();
//final long endAt = System.nanoTime();
//final double secs = (endAt - startAt) / 1000000000.0;
//System.out.println("Grammar generated in " + secs + "s.");
}
//-------------------------------------------------------------------------
/**
* Access grammar here.
* @return The singleton grammar object.
*/
public static Grammar grammar()
{
if (singleton == null)
{
synchronized(Grammar.class)
{
if (singleton == null)
singleton = new Grammar();
}
}
return singleton;
}
//-------------------------------------------------------------------------
/**
* @param name
* @return Map of symbols by name.
*/
public List<Symbol> symbolsByName(final String name)
{
return symbolsByName.get(name);
}
// /**
// * @return Map of symbols by partial keyword.
// */
// public Map<String, List<Symbol>> symbolsByPartialKeyword()
// {
// return symbolsByPartialKeyword;
// }
/**
* @return The list of the symbols.
*/
public List<Symbol> symbols()
{
return Collections.unmodifiableList(symbols);
}
//-------------------------------------------------------------------------
/**
* Note: This looks like a getter but also may do some processing.
*
* @return The EBNF.
*/
public EBNF ebnf()
{
if (ebnf == null)
ebnf = new EBNF(grammar().toString());
//findEBNFClasses(ebnf);
return ebnf;
}
//-------------------------------------------------------------------------
// /**
// * Do here in Grammar rather than EBNF, so EBNF doesn't depend on Grammar.
// */
// public void findEBNFClasses()
// {
// for (final EBNFRule rule : Grammar.grammar().ebnf().rules().values())
// {
// System.out.println("EBNF rule: " + rule);
// //final Class<?> cls = null;
// // ...
// //rule.setClass(cls);
// }
// }
//-------------------------------------------------------------------------
/**
* Generate the grammar from the current code base.
*/
void execute()
{
System.out.println("Ludii library " + Constants.LUDEME_VERSION + ".");
generate();
final String outFileName = "grammar-" + Constants.LUDEME_VERSION + ".txt";
System.out.println("Saving to file " + outFileName + ".");
try
{
export(outFileName);
}
catch (final Exception e)
{
e.printStackTrace();
}
}
//-------------------------------------------------------------------------
/**
* Generate grammar from the class library.
*/
public void generate()
{
symbols.clear();
getRules().clear();
packages.clear();
createSymbols();
disambiguateSymbols();
createRules();
addReturnTypeClauses();
addApplicationConstantsToRule();
crossReferenceSubclasses();
//replaceListFunctionArgs();
linkDirectionsRules();
linkRegionRules();
handleDimFunctions();
handleGraphAndRangeFunctions();
handleTrackSteps();
linkToPackages();
instantiateSingleEnums();
visitSymbols(rootGameSymbol);
visitSymbols(rootMetadataSymbol);
setDisplayOrder(rootGameSymbol);
removeRedundantFunctionNames();
createSymbolMap();
alphabetiseRuleClauses();
removeDuplicateClauses();
filterOutPrimitiveWrappers();
setUsedInGrammar();
setUsedInDescription();
setUsedInMetadata();
setLudemeTypes();
setAtomicLudemes();
findAncestors();
tidyUpFormat();
final boolean debug = FileHandling.isCambolbro() && false;
if (debug)
{
System.out.println(symbolDetails());
}
// System.out.println("=================\nPackages:");
// for (Package pack : packages)
// System.out.println(pack.path());
// System.out.println("\n=================\n");
// Show symbol count
int numGrammar = 0;
int numMetadata = 0;
int numClasses = 0;
int numConstants = 0;
int numPredefined = 0;
int numPrimitive = 0;
for (final Symbol symbol : symbols)
{
if (symbol.usedInDescription())
numGrammar++;
if (symbol.usedInMetadata())
numMetadata++;
if (symbol.isClass())
numClasses++;
if (symbol.ludemeType() == LudemeType.Constant)
numConstants++;
if (symbol.ludemeType() == LudemeType.Predefined)
numPredefined++;
if (symbol.ludemeType() == LudemeType.Primitive)
numPrimitive++;
}
if (debug)
{
System.out.println
(
symbols.size() + " symbols: " + numClasses + " classes, " +
numConstants + " constants, " + numPredefined + " predefined, " + numPrimitive + " primitives."
);
System.out.println(getRules().size() + " rules, " + numGrammar + " used in grammar, " +
numMetadata + " used in metadata.");
}
if (debug)
{
// Check ludemes used
System.out.println("Ludemes used:");
final List<LudemeInfo> ludemesUsed = ludemesUsed();
for (final LudemeInfo li : ludemesUsed)
System.out.println(li.symbol().token() + " (" + li.symbol().name() + ") : " + li.symbol().cls().getName());
}
}
//-------------------------------------------------------------------------
/**
* Create all symbols in the grammar.
*/
void createSymbols()
{
Symbol symbolInt = null;
// Create Primitive symbols
for (int pid = 0; pid < Primitives.length; pid++)
{
Class<?> cls = null;
if (Primitives[pid][0].equals("int"))
cls = int.class;
else if (Primitives[pid][0].equals("float"))
cls = float.class;
else if (Primitives[pid][0].equals("boolean"))
cls = boolean.class;
final Symbol symbol = new Symbol(LudemeType.Primitive, Primitives[pid][0], null, Primitives[pid][1], cls);
symbol.setReturnType(symbol); // returns itself
symbols.add(symbol);
if (Primitives[pid][0].equals("int"))
symbolInt = symbol;
}
// Create Predefined symbols
for (int pid = 0; pid < Predefined.length; pid++)
{
Class<?> cls = null;
try
{
cls = Class.forName(Predefined[pid][0]);
} catch (final ClassNotFoundException e)
{
e.printStackTrace();
}
final Symbol symbol = new Symbol
(
LudemeType.Predefined, Predefined[pid][0], null,
Predefined[pid][1], cls
);
symbol.setToken(Predefined[pid][3]);
symbol.setGrammarLabel(Predefined[pid][3]);
symbol.setReturnType(symbol); // returns itself
symbols.add(symbol);
}
// Create symbols for application constants
for (int cs = 0; cs < ApplicationConstants.length; cs++)
{
// **
// ** Assumes that all application constants are ints. Extend this if needed.
// **
final Class<?> cls = int.class;
final Symbol symbolC = new Symbol
(
LudemeType.Constant, ApplicationConstants[cs][0],
null, ApplicationConstants[cs][2], cls
);
symbolC.setReturnType(symbolInt);
symbols.add(symbolC);
}
// Traverse class hierarchy to generate symbols
findSymbolsFromClasses("game.Game");
findSymbolsFromClasses("metadata.Metadata");
checkHiddenClasses();
checkAbstractClasses();
handleEnums();
overrideReturnTypes();
// Check that appropriate symbols are included in grammar
// for (final Symbol symbol : symbols)
// //if (symbol.hasAlias())
// if (!symbol.name().equalsIgnoreCase(symbol.token()))
// symbol.setUsedInGrammar(true); // is probably an alias or remapped form something else
// // Ensure that functions are not used in grammar
// for (final Symbol symbol : symbols)
// if (symbol.name().contains("Function"))
// System.out.println("Symbol function found: " + symbol.info());
// Set root symbols
rootGameSymbol = null;
rootMetadataSymbol = null;
for (final Symbol symbol : symbols)
{
if (symbol.path().equals("game.Game"))
rootGameSymbol = symbol;
if (symbol.path().equals("metadata.Metadata"))
rootMetadataSymbol = symbol;
}
if (rootGameSymbol == null || rootMetadataSymbol == null)
throw new RuntimeException("Cannot find game.Game or metadata.Metadata.");
}
//-------------------------------------------------------------------------
/**
* Traverse files in library to find symbols.
*
* @param rootPackageName The root package name.
*/
public void findSymbolsFromClasses(final String rootPackageName)
{
Class<?> clsRoot = null;
try
{
clsRoot = Class.forName(rootPackageName);
}
catch (final ClassNotFoundException e)
{
e.printStackTrace();
}
final List<Class<?>> classes = ClassEnumerator.getClassesForPackage(clsRoot.getPackage());
for (final Class<?> cls : classes)
{
if (cls.getName().contains("$"))
continue; // is an internal class or enum?
if (cls.getName().contains("package-info"))
continue; // placeholder file for documentation
String alias = null;
// From: http://tutorials.jenkov.com/java-reflection/annotations.html
final Annotation[] annotations = cls.getAnnotations();
for (final Annotation annotation : annotations)
{
if (annotation instanceof Alias)
{
final Alias anno = (Alias)annotation;
alias = anno.alias();
}
}
final String classPath = cls.getName();
// **
// ** Assume it is Ludeme type until proven otherwise.
// **
final Symbol symbol = new Symbol(LudemeType.Ludeme, classPath, alias, cls);
symbol.setReturnType(symbol); // returns itself (unless superseded by eval())
symbols.add(symbol);
// Add this package name, if not already found
final Package pack = cls.getPackage();
final String packageName = pack.getName();
int p;
for (p = 0; p < packages.size(); p++)
if (packages.get(p).path().equals(packageName))
break;
if (p >= packages.size())
packages.add(new PackageInfo(packageName));
}
}
//-------------------------------------------------------------------------
void disambiguateSymbols()
{
for (int sa = 0; sa < symbols.size(); sa++)
{
final Symbol symbolA = symbols.get(sa);
if (!symbolA.isClass())
continue;
String grammarLabel = "";
for (int sb = 0; sb < symbols.size(); sb++)
{
if (sa == sb)
continue;
final Symbol symbolB = symbols.get(sb);
if (!symbolB.isClass())
continue;
if (symbolA.name().equals(symbolB.name()))
{
// Classes with same name found
final String label = symbolA.disambiguation(symbolB);
if (label == null)
continue;
if (label.length() > grammarLabel.length())
grammarLabel = new String(label);
}
}
if (grammarLabel != "")
symbolA.setGrammarLabel(grammarLabel);
}
}
//-------------------------------------------------------------------------
void createSymbolMap()
{
symbolsByName.clear();
for (final Symbol symbol : symbols)
{
final String key = symbol.name();
List<Symbol> list = symbolsByName.get(key);
if (list != null)
{
// Symbol(s) with same name already in map
list.add(symbol);
}
else
{
// Add symbol to new list
list = new ArrayList<Symbol>();
list.add(symbol);
symbolsByName.put(key, list);
}
}
// // Sort lists (shortest to longest)
// for (final List<Symbol> list : symbolsByName.values())
// {
// Collections.sort(list, new Comparator<Symbol>()
// {
// @Override
// public int compare(final Symbol sa, final Symbol sb)
// {
// final int lenA = sa.name().length();
// final int lenB = sb.name().length();
//
// if (lenA == lenB)
// return sa.name().compareTo(sb.name());
//
// return lenA < lenB ? -1 : 1;
// }
// });
// }
// Create map for partial keyword matches
symbolsByPartialKeyword.clear();
for (final Symbol symbol : symbols)
{
final String fullKey = symbol.token();
for (int i = 1; i < fullKey.length() + 1; i++)
{
final String key = fullKey.substring(0, i);
// System.out.println("key=" + key);
List<Symbol> list = symbolsByPartialKeyword.get(key);
if (list != null)
{
// Symbol(s) with same name already in map
list.add(symbol);
}
else
{
// Add symbol to new list
list = new ArrayList<Symbol>();
list.add(symbol);
symbolsByPartialKeyword.put(key, list);
}
}
}
//System.out.println(symbolMap.size() + " symbol entries.");
//System.out.println(symbolMapPartial.size() + " partial entries.");
}
//-------------------------------------------------------------------------
/**
* @param className May be class name or alias.
* @return Symbol list matching the specified keyword.
*/
public List<Symbol> symbolListFromClassName(final String className)
{
final List<Symbol> list = symbolsByName.get(className);
if (list != null)
return list; // found symbol by class name
// Check for aliases
for (final Symbol symbol : symbols)
if (symbol.token().equals(className))
return symbolsByName.get(symbol.name());
return null; // could not find
}
//-------------------------------------------------------------------------
/**
* @param partialKeyword The partial keyword.
* @return Symbols matching the given partial keyword.
*/
public List<Symbol> symbolsWithPartialKeyword(final String partialKeyword)
{
return symbolsByPartialKeyword.get(partialKeyword);
}
//-------------------------------------------------------------------------
/**
* @param description Game description (may be expanded or not).
* @param cursorAt Character position of cursor.
* @param usePartial True if we use the partial keywords.
* @return Paths of best matches for the keyword at the cursor position.
*/
public List<String> classPaths(final String description, final int cursorAt, final boolean usePartial)
{
final List<String> list = new ArrayList<String>();
if (cursorAt <= 0 || cursorAt >= description.length())
{
System.out.println("** Grammar.classPaths(): Invalid cursor position " + cursorAt + " specified.");
return list;
}
// Get partial keyword up to cursor
int c = cursorAt - 1;
char ch = description.charAt(c);
if (!StringRoutines.isTokenChar(ch))
{
// Not currently on a token (or at the start of one): return nothing
return list;
}
while (c > 0 && StringRoutines.isTokenChar(ch))
{
c--;
ch = description.charAt(c);
}
// Get full keyword
int cc = cursorAt;
char ch2 = description.charAt(cc);
while (cc < description.length() && StringRoutines.isTokenChar(ch2))
{
cc++;
if (cc < description.length())
ch2 = description.charAt(cc);
}
if (cc >= description.length())
{
System.out.println("** Grammar.classPaths(): Couldn't find end of token from position " + cursorAt + ".");
return list;
}
if (ch2 == ':')
{
// Token is a parameter name: return nothing
return list;
}
String partialKeyword = description.substring(c+1, cursorAt);
String fullKeyword = description.substring(c+1, cc);
boolean isRule = false;
if (partialKeyword.charAt(0) == '<')
{
isRule = true;
partialKeyword = partialKeyword.substring(1);
}
if (fullKeyword.charAt(0) == '<' && fullKeyword.charAt(fullKeyword.length() - 1) == '>')
{
isRule = true;
fullKeyword = fullKeyword.substring(1, fullKeyword.length() - 1);
}
if
(
description.charAt(c) == '<'
||
description.charAt(c) == '[' && description.charAt(c+1) == '<'
||
description.charAt(c) == '(' && description.charAt(c+1) == '<'
)
isRule = true;
// Handle primitive and predefined types
if (fullKeyword.charAt(0) == '"')
{
// Is a string: note that quotes '"' are a valid token character
list.add("java.lang.String");
return list;
}
else if (fullKeyword.equals("true"))
{
list.add("true");
}
else if (fullKeyword.equals("false"))
{
list.add("false");
}
else if (StringRoutines.isInteger(fullKeyword))
{
list.add("int");
}
else if (StringRoutines.isFloat(fullKeyword) || StringRoutines.isDouble(fullKeyword))
{
list.add("float");
}
// Find for matches
final String keyword = usePartial ? partialKeyword : fullKeyword;
final List<Symbol> matches = symbolsWithPartialKeyword(keyword);
if (matches == null)
{
// Nothing to return
return list;
}
// Filter out unwanted matches
if (ch == '(')
{
// Is a class constructor
for (final Symbol symbol : matches)
if (symbol.cls() != null && !symbol.cls().isEnum())
list.add(symbol.path());
}
else if (ch == '<' || isRule)
{
// Is a rule
for (final Symbol symbol : matches)
list.add(symbol.path());
}
else if (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == ':' || ch == '{')
{
// Is a terminal (probably an enum)
for (final Symbol symbol : matches)
if (symbol.cls() != null && symbol.cls().isEnum())
{
int lastDot = symbol.path().length() - 1;
while (lastDot >= 0 && symbol.path().charAt(lastDot) != '.')
lastDot--;
final String enumString = symbol.path().substring(0,lastDot) + '$' + symbol.path().substring(lastDot + 1);
list.add(enumString);
}
}
// Filter ludemes/metadata as appropriate
final int metadataAt = description.indexOf("(metadata");
final boolean inMetadata = metadataAt != -1 && metadataAt < cursorAt;
for (int n = list.size() - 1; n >= 0; n--)
{
final boolean isMetadata = list.get(n).contains("metadata.");
if (isMetadata && !inMetadata || !isMetadata && inMetadata)
list.remove(n);
}
return list;
}
//-------------------------------------------------------------------------
/**
* @param name
* @return Index of application constant with same name, else -1 if none.
*/
public static int applicationConstantIndex(final String name)
{
for (int ac = 0; ac < ApplicationConstants.length; ac++)
if (ApplicationConstants[ac][0].equals(name))
return ac;
return -1;
}
//-------------------------------------------------------------------------
/**
* Check for symbols that should be hidden.
*/
void checkHiddenClasses()
{
for (final Symbol symbol : symbols)
{
final Class<?> cls = symbol.cls();
if (cls == null)
continue;
final Annotation[] annos = cls.getAnnotations();
for (final Annotation anno : annos)
{
if (anno.annotationType().getName().equals("annotations.Hide"))
{
symbol.setHidden(true);
break;
}
}
}
}
//-------------------------------------------------------------------------
/**
* Determine which classes are abstract. These constitute rules rather than instances.
*/
void checkAbstractClasses()
{
for (final Symbol symbol : symbols)
{
final Class<?> cls = symbol.cls();
if (cls == null)
continue;
if (Modifier.isAbstract(cls.getModifiers()))
symbol.setIsAbstract(true);
}
}
//-------------------------------------------------------------------------
/**
* Handle enums (including inner classes).
*/
void handleEnums()
{
final List<Symbol> newSymbols = new ArrayList<Symbol>();
for (final Symbol symbol : symbols)
{
final Class<?> cls = symbol.cls();
if (cls == null)
continue;
if (cls.isEnum())
extractEnums(cls, symbol, newSymbols);
// Check for inner classes
for (final Class<?> inner : cls.getClasses())
{
if (inner.isEnum())
{
extractEnums(inner, symbol, newSymbols);
}
else
{
// Ignore inner classes that are not enums, even if they're ludemes
//System.out.println("!! Grammar.handleEnums(): Inner class found but not enum and not handled: ");
//System.out.println(" " + inner.getName() + "\n");
}
}
}
for (final Symbol newSymbol : newSymbols)
if (findSymbolMatch(newSymbol) == null)
symbols.add(newSymbol);
}
//-------------------------------------------------------------------------
/**
* Extract enums from class (including inner class).
*/
static void extractEnums(final Class<?> cls, final Symbol symbol, final List<Symbol> newSymbols)
{
final Symbol symbolEnum = new Symbol(LudemeType.Structural, cls.getName(), null, cls);
symbolEnum.setReturnType(symbolEnum);
newSymbols.add(symbolEnum);
for (final Object enumObj : cls.getEnumConstants())
{
final String symbolName = enumObj.toString();
final String path = symbolEnum.path() + "." + symbolName;
// Check for alias
String alias = null;
// From: https://clevercoder.net/2016/12/12/getting-annotation-value-enum-constant/
Field declaredField = null;
try
{
declaredField = cls.getDeclaredField(((Enum<?>)enumObj).name());
}
catch (final NoSuchFieldException e)
{
e.printStackTrace();
}
if (declaredField != null)
{
final Annotation[] annotations = declaredField.getAnnotations();
for (final Annotation annotation : annotations)
if (annotation instanceof Alias)
{
final Alias anno = (Alias)annotation;
alias = anno.alias();
}
}
final Symbol symbolValue = new Symbol
(
LudemeType.Constant, path, alias,
symbolEnum.notionalLocation(), cls
);
symbolValue.setReturnType(symbolEnum); // link value to its enum type
newSymbols.add(symbolValue);
}
}
//-------------------------------------------------------------------------
/**
* Override return types from classes with eval() method.
*/
void overrideReturnTypes()
{
final List<Symbol> newSymbols = new ArrayList<Symbol>();
for (final Symbol symbol : symbols)
{
if (!symbol.isClass())
continue;
final Class<?> cls = symbol.cls();
if (cls == null)
continue;
// Handle aliases here as well
String alias = null;
// From: http://tutorials.jenkov.com/java-reflection/annotations.html
final Annotation[] classAnnotations = cls.getAnnotations();
for (final Annotation annotation : classAnnotations)
{
if (annotation instanceof Alias)
{
final Alias anno = (Alias)annotation;
alias = anno.alias();
}
}
// Check for run() method
final Method[] methods = cls.getDeclaredMethods();
for (final Method method : methods)
{
if (!method.getName().equals("eval"))
continue;
final Type returnType = method.getReturnType();
if (returnType == null)
{
System.out.println("** Bad return type.");
continue;
}
final String returnTypeName = returnType.getTypeName();
if (returnTypeName.equals("void"))
continue;
// if (returnTypeName.equals("Moves"))
// continue;
final Symbol temp = new Symbol(null, returnTypeName, alias, cls);
Symbol returnSymbol = findSymbolByPath(temp.path());
if (returnSymbol == null)
{
continue;
}
if (symbol.nesting() != temp.nesting())
{
// Create a new return symbol for a collection of this symbol
returnSymbol = new Symbol(returnSymbol);
returnSymbol.setNesting(temp.nesting());
returnSymbol.setReturnType(returnSymbol);
newSymbols.add(returnSymbol);
}
symbol.setReturnType(returnSymbol);
}
}
for (final Symbol newSymbol : newSymbols)
if (findSymbolMatch(newSymbol) == null)
symbols.add(newSymbol);
}
//-------------------------------------------------------------------------
/**
* @param path
* @return Symbol with specified path, else null if not found.
*/
public Symbol findSymbolByPath(final String path)
{
for (final Symbol symbol : symbols)
if (symbol.path().equalsIgnoreCase(path))
return symbol;
return null;
}
//-------------------------------------------------------------------------
/**
* Create rules based on symbol return types.
*/
void createRules()
{
for (final Symbol symbol : symbols)
{
if (symbol.hidden())
continue; // skip hidden symbols
if (symbol.ludemeType() == LudemeType.Constant)
{
// Add constant clause to enum rule
final Symbol lhs = symbol.returnType();
final GrammarRule rule = getRule(lhs);
final Clause clause = new Clause(symbol);
rule.addToRHS(clause);
}
else
{
// Ensure that rule exists (or is created) for this symbol
final Symbol lhs = symbol;
final GrammarRule rule = getRule(lhs);
// Create clauses
if (symbol.isClass() && !symbol.isAbstract())
{
// Create constructor clause(s)
expandConstructors(rule, symbol);
}
else
{
// Add non-constructor clause
final Clause clause = new Clause(symbol);
if
(
!rule.containsClause(clause)
&&
(
symbol.ludemeType() == LudemeType.Primitive
||
symbol.ludemeType() == LudemeType.Predefined
||
!lhs.path().equals(symbol.path())
)
&& // avoid repetition of LHS collections on RHS
!(lhs.matches(symbol) && lhs.nesting() > 0)
)
{
rule.addToRHS(clause);
}
else
{
//System.out.println("- Failed test for generating clause for: " + symbol.name());
}
}
}
}
}
//-------------------------------------------------------------------------
/**
* @param lhs
* @return Rule with the specified LHS, creates new rule if necessary.
*/
GrammarRule getRule(final Symbol lhs)
{
for (final GrammarRule rule : getRules())
if (rule.lhs().matches(lhs))
return rule; // existing rule
// Create new rule
final GrammarRule rule = new GrammarRule(lhs);
getRules().add(rule);
return rule;
}
/**
* @param lhs
* @return Rule with the specified LHS, else null if not found.
*/
GrammarRule findRule(final Symbol lhs)
{
for (final GrammarRule rule : getRules())
if (rule.lhs().matches(lhs))
return rule;
return null;
}
/**
* @param path
* @return Package with the specified path, else null if none.
*/
public PackageInfo findPackage(final String path)
{
for (final PackageInfo pack : packages)
if (path.equalsIgnoreCase(pack.path()))
return pack;
return null;
}
//-------------------------------------------------------------------------
/**
* Expand constructors for this concrete base class.
*
* @param rule
* @param symbol
*/
void expandConstructors(final GrammarRule rule, final Symbol symbol)
{
if (symbol.hidden())
return;
final Class<?> cls = symbol.cls();
if (cls == null)
return;
// Handle aliases here as well
String alias = null;
// From: http://tutorials.jenkov.com/java-reflection/annotations.html
final Annotation[] classAnnotations = cls.getAnnotations();
for (final Annotation annotation : classAnnotations)
{
if (annotation instanceof Alias)
{
final Alias anno = (Alias)annotation;
alias = anno.alias();
}
}
// Get list of either constructors or construct() methods
final List<Executable> ctors = new ArrayList<Executable>();
// Get list of constructors
ctors.addAll(Arrays.asList(cls.getConstructors()));
// Get list of static construct() methods
final Method[] methods = cls.getDeclaredMethods();
for (final Method method : methods)
if (method.getName().equals("construct") && Modifier.isStatic(method.getModifiers()))
ctors.add(method);
for (final Executable ctor : ctors)
{
final List<ClauseArg> constructorArgs = new ArrayList<ClauseArg>();
final Annotation[] ctorAnnotations = ctor.getAnnotations();
final Annotation[][] annotations = ctor.getParameterAnnotations();
final Type[] types = ctor.getGenericParameterTypes();
final Parameter[] parameters = ctor.getParameters();
boolean isHidden = false;
for (int ca = 0; ca < ctorAnnotations.length; ca++)
{
final Annotation ann = ctorAnnotations[ca];
if (ann.annotationType().getName().equals("annotations.Hide"))
isHidden = true;
}
int prevOrType = 0; // 'or' type of previous item
int prevAndType = 0; // 'and' type of previous item
int orGroup = 0;
int andGroup = 0;
for (int n = 0; n < types.length; n++)
{
final Type type = types[n];
final String typeName = type.getTypeName();
// Args maintain own records of List<> and array[] nesting,
// so find base symbol without collections.
// **
// ** Assume it is Ludeme type unless proven otherwise.
// **
final Symbol temp = new Symbol(LudemeType.Ludeme, typeName, alias, cls); //null);
temp.setNesting(0);
final Symbol symbolP = findSymbolMatch(temp);
if (symbolP == null)
{
//System.out.println("- No matching symbolP found for symbol: " + symbol.name());
continue;
}
// Check for parameter name
String label = (n < parameters.length && parameters[n].isNamePresent())
? parameters[n].getName()
: null;
// Check for annotations
boolean optional = false;
boolean isNamed = false;
int orType = 0;
int andType = 0;
for (int a = 0; a < annotations[n].length; a++)
{
final Annotation ann = annotations[n][a];
if (ann.annotationType().getName().equals("annotations.Opt"))
optional = true;
if (ann.annotationType().getName().equals("annotations.Name"))
isNamed = true;
if (ann.annotationType().getName().equals("annotations.Or"))
orType = 1;
if (ann.annotationType().getName().equals("annotations.Or2"))
{
if (orType != 0)
System.out.println("** Both @Or and @Or2 specified for label.");
orType = 2;
}
if (ann.annotationType().getName().equals("annotations.And"))
andType = 1;
if (ann.annotationType().getName().equals("annotations.And2"))
{
if (andType != 0)
System.out.println("** Both @And and @And2 specified for label.");
andType = 2;
}
}
final String actualParameterName = (label == null) ? null : new String(label);
if (!isNamed)
label = null;
if (orType != 0 && orType != prevOrType)
orGroup++; // new consecutive 'or' group
if (andType != 0 && andType != prevAndType)
andGroup++; // new consecutive 'and' group
final ClauseArg arg = new ClauseArg
(
symbolP, actualParameterName, label, optional,
(orType == 0 ? 0 : orGroup),
(andType == 0 ? 0 : andGroup)
);
int nesting = 0;
for (int c = 0; c < typeName.length() - 1; c++)
if (typeName.charAt(c) == '[' && typeName.charAt(c + 1) == ']')
nesting++;
if (nesting > 0)
arg.setNesting(nesting);
constructorArgs.add(arg);
prevOrType = orType;
prevAndType = andType;
}
final Clause clause = new Clause(symbol, constructorArgs, isHidden);
rule.addToRHS(clause);
}
}
/**
* @param symbol
* @return Specified symbol, else null if not found.
*/
Symbol findSymbolMatch(final Symbol symbol)
{
for (final Symbol sym : symbols)
if (sym.matches(symbol))
return sym;
return null;
}
//-------------------------------------------------------------------------
/**
* Cross-reference subclass LHSs to clauses in superclass rules.
*/
void crossReferenceSubclasses()
{
for (final Symbol symbol : symbols)
{
if (!symbol.isClass())
continue;
if (symbol.hidden())
continue;
final Class<?> cls = symbol.cls();
if (cls == null)
continue;
final Class<?> clsSuper = cls.getSuperclass();
if (clsSuper == null)
continue;
final Symbol symbolSuper = findSymbolByPath(clsSuper.getName());
if (symbolSuper == null)
continue;
final GrammarRule ruleSuper = findRule(symbolSuper);
if (ruleSuper == null)
continue;
final Clause clause = new Clause(symbol);
if (!ruleSuper.containsClause(clause))
ruleSuper.addToRHS(clause);
}
}
//-------------------------------------------------------------------------
/**
* Add clauses for rules of overridden return types.
*/
void addReturnTypeClauses()
{
for (final Symbol symbol : symbols)
{
// final boolean isAdd = symbol.cls().getName().equals("game.functions.graph.operators.Add");
// if (isAdd)
// System.out.println("\n" + symbol.cls().getName());
if (!symbol.isClass() || symbol.matches(symbol.returnType()))
continue; // not overridden
if (symbol.hidden())
continue;
final GrammarRule rule = findRule(symbol.returnType());
if (rule == null)
continue;
final Clause clause = new Clause(symbol);
if (!rule.containsClause(clause))
{
rule.addToRHS(clause);
// if (isAdd)
// System.out.println("- Adding clause to rule: " + rule);
}
}
}
//-------------------------------------------------------------------------
void addApplicationConstantsToRule()
{
// Find <int> symbol and rule
Symbol symbolInt = null;
for (final Symbol symbol : symbols)
if (symbol.grammarLabel().equals("int"))
{
symbolInt = symbol;
break;
}
if (symbolInt == null)
throw new RuntimeException("Failed to find symbol for <int>.");
final GrammarRule ruleInt = findRule(symbolInt);
if (ruleInt == null)
throw new RuntimeException("Failed to find <int> rule.");
// Find each constant symbol and add to <int> rule
for (int cs = 0; cs < ApplicationConstants.length; cs++)
for (final Symbol symbol : symbols)
if (symbol.grammarLabel().equals(ApplicationConstants[cs][0]))
{
ruleInt.addToRHS(new Clause(symbol));
break;
}
}
//-------------------------------------------------------------------------
/**
* Link symbols and rules to packages.
*/
void linkToPackages()
{
// Cross-reference symbols to their packages
for (final Symbol symbol : symbols)
symbol.setPack(findPackage(symbol.notionalLocation()));
// List rules per packages
for (final GrammarRule rule : getRules())
{
final PackageInfo pack = rule.lhs().pack();
// Hack to stop duplicate rules showing for primitives.
//
// TODO: Stop out why these redundant rules are being added in the first place.
// CBB: Does not affect operation, not urgent, fix when convenient.
//
if
(
(
rule.lhs().grammarLabel().equals("int")
||
rule.lhs().grammarLabel().equals("boolean")
||
rule.lhs().grammarLabel().equals("float")
)
&&
rule.rhs().size() == 1
)
continue;
if (pack != null)
pack.add(rule);
}
}
//-------------------------------------------------------------------------
/**
* Set display order of rules and packages.
*/
void setDisplayOrder(final Symbol rootSymbol)
{
// Order packages in depth-first order from root package
for (final PackageInfo pack : packages)
{
pack.listAlphabetically();
prioritiseSuperClasses(pack);
prioritisePackageClass(pack);
}
setPackageOrder(rootSymbol);
}
//-------------------------------------------------------------------------
/**
* Order rules within each package so the base class comes first.
* @param pack
*/
static void prioritisePackageClass(final PackageInfo pack)
{
//final List<GrammarRule> rulesP = pack.rules();
// First pass: Promote partial match (e.g. "player")
final List<GrammarRule> promote = new ArrayList<GrammarRule>();
for (int r = pack.rules().size()-1; r >= 0; r--)
{
final GrammarRule rule = pack.rules().get(r);
if
(
pack.path().contains(rule.lhs().grammarLabel())
&&
rule.lhs().grammarLabel().length() >= 3 // avoid trivial matches such as "le" in "boolean"
)
{
// Partial match found
pack.remove(r);
//rulesP.add(0, rule);
promote.add(rule);
// break;
// System.out.println("Promoting rule " + rule.lhs().name() + " (A).");
}
}
for (final GrammarRule rule : promote)
pack.add(0, rule);
// Second pass: Promote exact match (e.g. "players")
promote.clear();
for (int r = pack.rules().size()-1; r >= 0; r--)
{
final GrammarRule rule = pack.rules().get(r);
if (pack.path().equals(rule.lhs().name()))
{
// Exact match found
pack.remove(r);
//rulesP.add(0, rule);
promote.add(rule);
// break;
// System.out.println("Promoting rule " + rule.lhs().name() + " (B).");
}
}
for (final GrammarRule rule : promote)
pack.add(0, rule);
}
//-------------------------------------------------------------------------
/**
* Prioritise rule order within packages so that superclasses come before
* subclasses.
*
* @param pack
*/
static void prioritiseSuperClasses(final PackageInfo pack)
{
// Move symbol with same name as package to top of package list
for (int n = 0; n < pack.rules().size(); n++)
{
final GrammarRule rule = pack.rules().get(n);
if (rule.lhs().name().equalsIgnoreCase(pack.shortName()))
{
pack.remove(n);
pack.add(0, rule);
}
}
// Swap when collection of symbols is in wrong order
for (int a = 0; a < pack.rules().size(); a++)
{
final GrammarRule ruleA = pack.rules().get(a);
for (int b = a + 1; b < pack.rules().size(); b++)
{
final GrammarRule ruleB = pack.rules().get(b);
if (ruleB.lhs().isCollectionOf(ruleA.lhs()))
{
pack.remove(b);
pack.remove(a);
pack.add(a, ruleB);
pack.add(b, ruleA);
}
}
}
}
//-------------------------------------------------------------------------
void linkDirectionsRules()
{
// Add clauses for <directionFacing> rule
final Symbol symbolDirectionFacing = findSymbolByPath("game.util.directions.DirectionFacing");
symbolDirectionFacing.setUsedInGrammar(true);
final Symbol symbolCompass = findSymbolByPath("game.util.directions.CompassDirection");
symbolCompass.setUsedInGrammar(true);
final Symbol symbolRotational = findSymbolByPath("game.util.directions.RotationalDirection");
symbolCompass.setUsedInGrammar(true);
final Symbol symbolSpatial = findSymbolByPath("game.util.directions.SpatialDirection");
symbolSpatial.setUsedInGrammar(true);
final GrammarRule ruleDirectionFacing = findRule(symbolDirectionFacing);
ruleDirectionFacing.addToRHS(new Clause(symbolCompass));
ruleDirectionFacing.addToRHS(new Clause(symbolRotational));
ruleDirectionFacing.addToRHS(new Clause(symbolSpatial));
// Add clauses for <direction> rule
final Symbol symbolAbsolute = findSymbolByPath("game.util.directions.AbsoluteDirection");
symbolAbsolute.setUsedInGrammar(true);
final Symbol symbolRelative = findSymbolByPath("game.util.directions.RelativeDirection");
symbolRelative.setUsedInGrammar(true);
final Symbol symbolDirections = findSymbolByPath("game.functions.directions.Directions");
symbolDirections.setUsedInDescription(true);
symbolDirections.setUsedInGrammar(true);
final Symbol symbolIf = findSymbolByPath("game.functions.directions.If");
symbolIf.setUsedInDescription(true);
symbolIf.setUsedInGrammar(true);
// ruleDirectionFacing.addToRHS(new Clause(symbolAbsolute));
// ruleDirectionFacing.addToRHS(new Clause(symbolRelative));
// ruleDirectionFacing.addToRHS(new Clause(symbolDirections));
// ruleDirectionFacing.addToRHS(new Clause(symbolIf));
// Add clauses for <direction>
final Symbol symbolDirection = findSymbolByPath("game.util.directions.Direction");
symbolDirection.setUsedInGrammar(true);
final GrammarRule ruleDirection = findRule(symbolDirection);
ruleDirection.addToRHS(new Clause(symbolAbsolute));
ruleDirection.addToRHS(new Clause(symbolRelative));
ruleDirection.addToRHS(new Clause(symbolDirections));
ruleDirection.addToRHS(new Clause(symbolIf));
}
//-------------------------------------------------------------------------
void linkRegionRules()
{
final Symbol symbolRegion = findSymbolByPath("game.util.equipment.Region");
final GrammarRule ruleRegion = findRule(symbolRegion);
final Symbol symbolSites = findSymbolByPath("game.functions.region.sites.Sites");
final GrammarRule ruleSites = findRule(symbolSites);
for (final Clause clause : ruleRegion.rhs())
ruleSites.addToRHS(clause);
symbolRegion.setUsedInDescription(false);
symbolSites.setUsedInDescription(true);
// Remove <equipment.region> rule
for (int r = getRules().size() - 1; r >= 0; r--)
{
final GrammarRule rule = getRules().get(r);
if (rule.lhs().grammarLabel().equals("equipment.region"))
getRules().remove(r);
}
}
//-------------------------------------------------------------------------
void handleDimFunctions()
{
// Find <dim> symbol and rule
final Symbol symbolDim = findSymbolByPath("game.functions.dim.BaseDimFunction");
symbolDim.setUsedInDescription(true);
final GrammarRule ruleDim = findRule(symbolDim);
// Find <int> symbol
Symbol symbolInt = null;
for (final Symbol symbol : symbols)
if (symbol.grammarLabel().equals("int"))
{
symbolInt = symbol;
break;
}
if (symbolInt == null)
throw new RuntimeException("Failed to find symbol for <int>.");
ruleDim.addToRHS(new Clause(symbolInt));
}
void handleGraphAndRangeFunctions()
{
final Symbol symbolGraph = findSymbolByPath("game.functions.graph.BaseGraphFunction");
symbolGraph.setUsedInGrammar(true);
symbolGraph.setUsedInDescription(true);
final Symbol symbolRange = findSymbolByPath("game.functions.range.BaseRangeFunction");
symbolRange.setUsedInGrammar(true);
symbolRange.setUsedInDescription(true);
}
/**
* Remove class name from track step declarations.
*/
void handleTrackSteps()
{
// final Symbol symbolTrackStep = findSymbolByPath("game.util.equipment.TrackStep");
// final GrammarRule ruleTrackStep = findRule(symbolTrackStep);
//
// final Symbol symbolDim = findSymbolByPath("game.functions.dim.BaseDimFunction");
// //final GrammarRule ruleDim = findRule(symbolDim);
//
// final Symbol symbolDirn = findSymbolByPath("game.util.directions.Compass");
// //final GrammarRule ruleDirn = findRule(symbolDirn);
//
// final Symbol symbolStep = findSymbolByPath("game.types.board.TrackStepType");
// //final GrammarRule ruleStep = findRule(symbolStep);
//
// ruleTrackStep.clearRHS();
//
// ruleTrackStep.addToRHS(new Clause(symbolDim));
// ruleTrackStep.addToRHS(new Clause(symbolDirn));
// ruleTrackStep.addToRHS(new Clause(symbolStep));
}
//-------------------------------------------------------------------------
/**
* Set package order for printing.
*/
void visitSymbols(final Symbol rootSymbol)
{
if (rootSymbol == null)
{
System.out.println("** GrammarWriter.visitSymbols() error: Null root symbol.");
return;
}
final boolean isGame = rootSymbol.name().contains("Game");
// Don't initialise values, as <directions> would not be picked up
// // Prepare export queue, depth first from root
// for (final Symbol symbol : symbols)
// {
// symbol.setVisited(false);
// symbol.setDepth(Constants.UNDEFINED);
//
// if (isGame)
// symbol.setUsedInGrammar(false);
// else
// symbol.setUsedInMetadata(false);
// }
visitSymbol(rootSymbol, 0, isGame);
}
/**
* Visit symbols in depth first order and record packages in order.
* @param symbol
*/
void visitSymbol(final Symbol symbol, final int depth, final boolean isGame)
{
if (symbol == null)
return; // no effect on which rules to show
if (symbol.depth() == Constants.UNDEFINED)
symbol.setDepth(depth);
else if (depth < symbol.depth())
symbol.setDepth(depth); // overwrite existing depth with a shallower one
if (symbol.visited())
return;
if (isGame)
{
//symbol.setUsedInDescription(true);
symbol.setUsedInGrammar(true);
}
else
{
symbol.setUsedInMetadata(true);
}
symbol.setVisited(true);
if (symbol.ludemeType() == LudemeType.Constant)
return;
if (symbol.rule() == null || symbol.rule().rhs() == null)
return; // probably redirected return type
if (symbol.rule().rhs() == null)
System.out.println("* Symbol with null expression: " + symbol.grammarLabel()); //symbol.name());
// Don't add steps for abstract or hidden classes, which do not appear in the grammar
final boolean isVisible = !symbol.isAbstract() && !symbol.hidden();
final int nextDepth = depth + (isVisible ? 1 : 0);
// Recurse to embedded symbols in RHS expression
for (final Clause clause : symbol.rule().rhs())
{
visitSymbol(clause.symbol(), nextDepth, isGame);
// Check for matching clause symbols
for (final GrammarRule ruleC : getRules())
if (ruleC.lhs().validReturnType(clause))
visitSymbol(ruleC.lhs().returnType(), nextDepth, isGame);
// **
// ** TODO: Have more general arg matching, e.g. play() is easily missed.
// **
// Check for matching arg symbols
if (clause.args() != null) // is a constructor
for (final ClauseArg arg : clause.args())
{
visitSymbol(arg.symbol(), nextDepth, isGame);
for (final GrammarRule ruleA : getRules())
if (ruleA.lhs().validReturnType(arg))
visitSymbol(ruleA.lhs().returnType(), nextDepth, isGame);
}
}
}
//-------------------------------------------------------------------------
/**
* Set package order for printing.
*/
void setPackageOrder(final Symbol rootSymbol)
{
packageOrder.clear();
if (rootSymbol == null)
{
System.out.println("** GrammarWriter.setPackageOrder() error: Null root symbol.");
return;
}
// Prepare export queue, depth first from root
for (final Symbol symbol : symbols)
symbol.setVisited(false);
setPackageOrderRecurse(rootSymbol);
// Move utility packages to end of list
final String[] packsToMove =
{
"game.functions",
"game.util",
"game.types",
};
for (int pm = 0; pm < packsToMove.length; pm++)
for (int p = packageOrder.size()-1; p >= 0; p--)
if (packageOrder.get(p).path().contains(packsToMove[pm]))
{
// Move this package to the bottom of the list
final PackageInfo packInfo = packageOrder.get(p);
packageOrder.remove(p);
packageOrder.add(packInfo);
}
}
/**
* Visit symbols in depth first order and record packages in order.
* @param symbol
*/
void setPackageOrderRecurse(final Symbol symbol)
{
if (symbol == null || symbol.visited() || symbol.ludemeType() == LudemeType.Constant)
return; // no effect on which rules to show
symbol.setVisited(true);
if (symbol.rule() == null || symbol.rule().rhs() == null)
return; // probably redirected return type
final PackageInfo pack = symbol.pack();
if (pack == null)
{
//System.out.println("* Null pack for symbol='" + symbol.toString() + "'.");
return; // probably String
}
int p;
for (p = 0; p < packageOrder.size(); p++)
if (packageOrder.get(p).path().equals(pack.path()))
break;
if (p >= packageOrder.size())
packageOrder.add(pack); // add unvisited package to the list
if (symbol.rule().rhs() == null)
{
System.out.println("* Symbol with null expression: " + symbol.grammarLabel()); //symbol.name());
}
// Recurse to embedded symbols in RHS expression
for (final Clause clause : symbol.rule().rhs())
{
setPackageOrderRecurse(clause.symbol());
// Check for matching clause symbols
for (final GrammarRule ruleC : getRules())
if (ruleC.lhs().validReturnType(clause))
{
setPackageOrderRecurse(ruleC.lhs().returnType());
}
// **
// ** TODO: Have more general arg matching, e.g. play() is easily missed.
// **
// Check for matching arg symbols
if (clause.args() != null) // is a constructor
for (final ClauseArg arg : clause.args())
{
setPackageOrderRecurse(arg.symbol());
for (final GrammarRule ruleA : getRules())
if (ruleA.lhs().validReturnType(arg))
setPackageOrderRecurse(ruleA.lhs().returnType());
}
}
}
//-------------------------------------------------------------------------
/**
* Remove rules and clauses with redundant function and constant names.
*/
void removeRedundantFunctionNames()
{
for (final GrammarRule rule : getRules())
{
// Remove redundant function rules by turning off LHS
for (int f = 0; f < getFunctions().length; f++)
if (rule.lhs().grammarLabel().equalsIgnoreCase(getFunctions()[f][0]))
{
rule.lhs().setUsedInDescription(false);
rule.lhs().setUsedInMetadata(false);
}
// Remove redundant clauses from rules
for (int c = rule.rhs().size() - 1; c >= 0; c--)
{
final Clause clause = rule.rhs().get(c);
for (int f = 0; f < getFunctions().length; f++)
if (clause.symbol().grammarLabel().equalsIgnoreCase(getFunctions()[f][0]))
{
rule.removeFromRHS(c);
break;
}
}
}
}
//-------------------------------------------------------------------------
void alphabetiseRuleClauses()
{
for (final GrammarRule rule : getRules())
rule.alphabetiseClauses();
}
//-------------------------------------------------------------------------
/**
* Removes duplicate clauses from rules,
* For example, <int> ::= Off | Off
*
* BE CAREFUL: Do not eliminate multiple constructors!
*
*/
void removeDuplicateClauses()
{
for (final GrammarRule rule : getRules())
{
for (int ca = rule.rhs().size() - 1; ca >= 0; ca--)
{
final Clause clauseA = rule.rhs().get(ca);
if (clauseA.isConstructor())
continue; // don't remove
boolean doRemove = false;
for (int cb = ca - 1; cb >= 0; cb--)
{
final Clause clauseB = rule.rhs().get(cb);
if (clauseA.matches(clauseB))
{
doRemove = true;
break;
}
}
if (doRemove)
rule.removeFromRHS(ca);
}
}
}
//-------------------------------------------------------------------------
/**
* Filter out redundant rules for primitive wrapper classes
*/
void filterOutPrimitiveWrappers()
{
// Filter out trivial rules that map primitive filters to themselves
for (final GrammarRule rule : getRules())
{
if
(
rule.lhs().grammarLabel().equals("Integer")
&&
rule.rhs().size() == 1
&&
rule.rhs().get(0).symbol().grammarLabel().equals("Integer")
||
rule.lhs().grammarLabel().equals("Float")
&&
rule.rhs().size() == 1
&&
rule.rhs().get(0).symbol().grammarLabel().equals("Float")
||
rule.lhs().grammarLabel().equals("Boolean")
&&
rule.rhs().size() == 1
&&
rule.rhs().get(0).symbol().grammarLabel().equals("Boolean")
||
rule.lhs().grammarLabel().equals("String")
&&
rule.rhs().size() == 1
&&
rule.rhs().get(0).symbol().grammarLabel().equals("String")
)
{
rule.lhs().setUsedInDescription(false); // turn off so is not shown in grammar
rule.lhs().setUsedInMetadata(false); // turn off so is not shown in grammar
}
}
// Replace primitive wrapper symbols on RHS with their primitive equivalents
Symbol symbolInt = null;
Symbol symbolFloat = null;
Symbol symbolBoolean = null;
Symbol symbolString = null;
// Symbol symbolTrue = null;
// Symbol symbolFalse = null;
for (final Symbol symbol : symbols)
{
if (symbol.grammarLabel().equals("int"))
symbolInt = symbol;
if (symbol.grammarLabel().equals("float"))
symbolFloat = symbol;
if (symbol.grammarLabel().equals("boolean"))
symbolBoolean = symbol;
if (symbol.grammarLabel().equals("String"))
symbolString = symbol;
// if (symbol.grammarLabel().equals("true"))
// symbolTrue = symbol;
// if (symbol.grammarLabel().equals("false"))
// symbolFalse = symbol;
}
for (final GrammarRule rule : getRules())
for (final Clause clause : rule.rhs())
if (clause != null && clause.args() != null)
for (final ClauseArg arg : clause.args())
{
if (arg.symbol().grammarLabel().equals("Integer"))
arg.setSymbol(symbolInt);
if (arg.symbol().grammarLabel().equals("Float"))
arg.setSymbol(symbolFloat);
if (arg.symbol().grammarLabel().equals("Boolean"))
arg.setSymbol(symbolBoolean);
if (arg.symbol().grammarLabel().equals("String"))
arg.setSymbol(symbolString);
}
// // Add 'true' and 'false' constants to <boolean> rule
// for (final GrammarRule rule : rules)
// if (rule.lhs().grammarLabel().equals("boolean"))
// {
// rule.add(new Clause(symbolTrue));
// rule.add(new Clause(symbolFalse));
// }
// // Remove rule for primitive wrappers
// for (int r = rules.size() - 1; r >= 0; r--)
// {
// final GrammarRule rule = rules.get(r);
//
// //System.out.println("Rule for: " + rule.lhs().cls().getName());
//
// if
// (
// rule.lhs().cls().getName().equals("java.lang.Integer")
// ||
// rule.lhs().cls().getName().equals("java.lang.Boolean")
// ||
// rule.lhs().cls().getName().equals("java.lang.Float")
// ||
// rule.lhs().cls().getName().contains("Function")
// ||
// rule.lhs().cls().getName().contains("Constant")
// )
// {
// //System.out.println("** Removing rule for: " + rule.lhs().cls().getName());
// rule.lhs().setUsedInGrammar(false);
// rule.lhs().setUsedInDescription(false);
// rule.lhs().setUsedInMetadata(false);
//
// rules.remove(r);
// }
// }
}
//-------------------------------------------------------------------------
/**
* Instantiate enums in-place if they only have one value.
*/
void instantiateSingleEnums()
{
// Instantiate single enum values
for (final GrammarRule rule : getRules())
for (final Clause clause : rule.rhs())
if (clause != null && clause.args() != null)
for (int a = clause.args().size() - 1; a >= 0; a--)
{
final ClauseArg arg = clause.args().get(a);
final Symbol symbol = arg.symbol();
if (symbol.cls() != null && symbol.cls().isEnum())
{
final GrammarRule ruleS = symbol.rule();
if (ruleS != null && ruleS.rhs().size() == 1)
{
final Clause enumValue = ruleS.rhs().get(0);
arg.setSymbol(enumValue.symbol());
enumValue.symbol().setUsedInGrammar(true);
}
}
}
// Remove enum rules with a single value (should have all been picked up by previous test)
for (int r = getRules().size() - 1; r >= 0; r--)
{
final GrammarRule rule = getRules().get(r);
if (rule.lhs().cls() != null && rule.lhs().cls().isEnum() && rule.rhs().size() == 1)
getRules().remove(r);
}
}
//-------------------------------------------------------------------------
/**
* @return Returns a string containing the path abbreviation for each ludeme and the name of the ludeme.
*/
public String getFormattedSymbols()
{
String str = "";
for (final Symbol s : symbols)
{
final String[] pathList = s.path().split("\\.");
String strAbrev = "";
for (int i = 0; i < pathList.length; i++)
{
strAbrev += pathList[i].charAt(0);
}
str += "\n" + strAbrev + " : " + s.toString().replace("<", "").replace(">", "");
}
return str;
}
//-------------------------------------------------------------------------
/**
* Export grammar to file.
* @param fileName
* @throws IOException
*/
public void export(final String fileName) throws IOException
{
final File file = new File(fileName);
if (!file.exists())
file.createNewFile();
try
(
final FileWriter fw = new FileWriter(file.getName(), false);
final BufferedWriter writer = new BufferedWriter(fw);
)
{
final String str = toString();
writer.write(str);
}
}
//-------------------------------------------------------------------------
/**
* Tidy up final result, including replacing function names with return types.
*/
private void tidyUpFormat()
{
// Replace remaining function names
for (int f = 0; f < getFunctions().length; f++)
{
String name = getFunctions()[f][0];
name = name.substring(0, 1).toLowerCase() + name.substring(1); // lowerCamelCase keyword
for (final GrammarRule rule : rules)
{
String label = rule.lhs().grammarLabel();
if (label.contains(name))
{
label = label.replace(name, getFunctions()[f][1]);
rule.lhs().setGrammarLabel(label);
}
}
}
}
//-------------------------------------------------------------------------
/**
* Set flag for ludemes used in the grammar.
*/
private void setUsedInGrammar()
{
// Start with all symbols that can occur in descriptions and metadata
for (final Symbol symbol : symbols)
{
if
(
symbol.usedInDescription()
// ||
// symbol.usedInMetadata()
)
{
symbol.setUsedInGrammar(true);
continue;
}
}
// Iteratively find rules that use them
boolean didUpdate = false;
do
{
didUpdate = false;
for (final GrammarRule rule : rules)
{
if (rule.lhs().usedInGrammar())
for (final Clause clause : rule.rhs())
if (!clause.symbol().usedInGrammar())
{
clause.symbol().setUsedInGrammar(true);
didUpdate = true;
}
}
} while (didUpdate);
}
//-------------------------------------------------------------------------
/**
* Set flag for ludemes used in game descriptions.
* These will have instantiations in RHS rule clauses.
*/
private void setUsedInDescription()
{
for (final GrammarRule rule : rules)
for (final Clause clause : rule.rhs())
{
final Symbol symbol = clause.symbol();
if (!symbol.usedInGrammar())
continue; // don't include metadata
if
(
clause.isConstructor()
||
symbol.isTerminal()
)
symbol.setUsedInDescription(true);
if (clause.args() != null)
{
// Also check clause args for enum constants etc.
for (final ClauseArg arg : clause.args())
{
final Symbol argSymbol = arg.symbol();
if (!argSymbol.usedInGrammar())
continue; // don't include metadata
if (argSymbol.isTerminal())
argSymbol.setUsedInDescription(true);
}
}
}
}
//-------------------------------------------------------------------------
/**
* Set flag for ludemes used in metadata.
*/
private void setUsedInMetadata()
{
for (final Symbol symbol : symbols)
{
// if (symbol.cls() != null && MetadataItem.class.isAssignableFrom(symbol.cls()))
// {
// System.out.println("Metadata symbol path: " + symbol.path());
// symbol.setUsedInMetadata(true);
// }
// Avoid dependency on Core
if (symbol.path().contains("metadata"))
symbol.setUsedInMetadata(true);
}
for (final GrammarRule rule : rules)
for (final Clause clause : rule.rhs())
{
final Symbol symbol = clause.symbol();
if (!symbol.usedInMetadata())
continue; // don't include grammar
if (clause.args() != null)
{
// Check metadata clause args
for (final ClauseArg arg : clause.args())
{
final Symbol argSymbol = arg.symbol();
argSymbol.setUsedInMetadata(true);
}
}
}
}
//-------------------------------------------------------------------------
/**
* Set ludeme type for each symbol.
*/
private void setLudemeTypes()
{
for (final Symbol symbol : symbols)
{
final Class<?> cls = symbol.cls();
if (cls == null)
{
// Symbol has no class
System.out.println("Symbol has no class: " + symbol);
symbol.setLudemeType(null);
continue;
}
if (cls.isEnum())
{
symbol.setLudemeType(LudemeType.Constant);
}
else if
(
cls.getSimpleName().equals("String")
||
cls.getSimpleName().equals("Integer")
||
cls.getSimpleName().equals("Float")
||
cls.getSimpleName().equals("Boolean")
)
{
symbol.setLudemeType(LudemeType.Predefined);
}
else if
(
cls.getSimpleName().equals("int")
||
cls.getSimpleName().equals("float")
||
cls.getSimpleName().equals("boolean")
)
{
symbol.setLudemeType(LudemeType.Primitive);
}
else
{
// Must be a ludeme class
if (cls.isInterface())
{
// Assume is structural rule that links subrules but is never instantiated
//System.out.println("** Is an interface: " + this);
symbol.setLudemeType(LudemeType.Structural);
}
else
{
// Check for super ludeme
final Constructor<?>[] constructors = cls.getConstructors();
if (constructors.length == 0)
{
// No constructors: probably a super ludeme
//System.out.println("** No constructors found for: " + this);
symbol.setLudemeType(LudemeType.SuperLudeme);
}
else
{
symbol.setLudemeType(LudemeType.Ludeme);
}
}
}
}
// Overwrite ludemes that appear in grammar but not descriptions as structural
for (final GrammarRule rule : rules)
{
final Symbol symbol = rule.lhs();
if
(
(symbol.usedInGrammar() || symbol.usedInMetadata())
&&
!symbol.usedInDescription()
)
symbol.setLudemeType(LudemeType.Structural);
}
// Class<?> clsT = null;
// try
// {
// clsT = Class.forName("game.types.play.GravityType");
// } catch (ClassNotFoundException e)
// {
// e.printStackTrace();
// }
// System.out.println(clsT);
// System.out.println("Is enum: " + clsT.isEnum());
// Check for incorrectly labelled enum types
for (final Symbol symbol : symbols)
{
final Class<?> cls = symbol.cls();
if (cls.isEnum() && symbol.ludemeType() == LudemeType.Constant)
{
// Is classified as an enum constant
// System.out.println("Enum class " + symbol.token() + " is type: " + symbol.ludemeType());
// Check if is actually a constant...
boolean isConstant = false;
final Object[] constants = cls.getEnumConstants();
for (final Object obj : constants)
if (obj.toString().equals(symbol.token()))
{
// System.out.println("- Constant obj: " + obj.toString());
isConstant = true;
break;
}
if (!isConstant)
{
// Correct this mistakenly classified enum class
symbol.setLudemeType(LudemeType.Ludeme);
//symbol.setSymbolType(SymbolType.Class);
}
}
}
findSubludemes();
}
// /**
// * Find subludemes.
// * These will be be classes in the subfolder of a superludeme (or below)
// * that are not in the grammar or game descriptions.
// */
// private void findSubludemes()
// {
// // Find all super ludemes and store package
// final Map<String, Symbol> supers = new HashMap<>();
// for (final Symbol symbol : symbols)
// if (symbol.ludemeType() == LudemeType.SuperLudeme)
// {
// String path = symbol.path();
// path = path.substring(0, path.lastIndexOf('.'));
// supers.put(path, symbol);
// }
//
// // Find all ludeme classes that do not appear in grammar
// // and are in a superludeme package (or below).
// for (final Symbol symbol : symbols)
// {
// if (symbol.ludemeType() != LudemeType.Ludeme)
// continue; // can't be a subludeme
//
// if (symbol.usedInGrammar() || symbol.usedInDescription())
// continue; // can't be a subludeme
//
// if (symbol.name().contains("Type"))
// {
// // is parameter type class
// symbol.setLudemeType(LudemeType.Structural);
// continue;
// }
//
// for (final String superPath : supers.keySet())
// if (symbol.path().contains(superPath))
// {
// symbol.setLudemeType(LudemeType.SubLudeme);
// break;
// }
// }
// }
/**
* Find subludemes.
* These will be be classes in the subfolder of a superludeme (or below)
* that are not in the grammar or game descriptions.
*/
private void findSubludemes()
{
// Find all super ludemes and store package
final Map<String, Symbol> supers = new HashMap<>();
for (final Symbol symbol : symbols)
if (symbol.ludemeType() == LudemeType.SuperLudeme)
{
String path = symbol.path();
path = path.substring(0, path.lastIndexOf('.'));
supers.put(path, symbol);
}
// Find all ludeme classes that do not appear in grammar
// and are in a superludeme package (or below).
for (final Symbol symbol : symbols)
{
if (symbol.ludemeType() != LudemeType.Ludeme)
continue; // can't be a subludeme
if (symbol.usedInGrammar() || symbol.usedInDescription())
continue; // can't be a subludeme
if (symbol.name().contains("Type"))
{
// is parameter type class
symbol.setLudemeType(LudemeType.Structural);
// if (symbol.name().equalsIgnoreCase("isLineType"))
// System.out.println("IsLineType subludeme found...");
// Catch super ludeme parameter enum types
for (final String superPath : supers.keySet())
if (symbol.path().contains(superPath))
symbol.setSubLudemeOf(supers.get(superPath));
continue;
}
for (final String superPath : supers.keySet())
if (symbol.path().contains(superPath))
{
symbol.setLudemeType(LudemeType.SubLudeme);
symbol.setSubLudemeOf(supers.get(superPath));
break;
}
}
// Now catch super ludeme enum parameter types
for (final Symbol symbol : symbols)
{
if (symbol.ludemeType() != LudemeType.Ludeme)
continue; // can't be a subludeme
if (!symbol.name().contains("Type"))
continue; // not a super ludeme enum parameter type
for (final String superPath : supers.keySet())
if (symbol.path().contains(superPath))
{
if (symbol.usedInGrammar() || symbol.usedInDescription())
symbol.setLudemeType(LudemeType.Structural);
symbol.setSubLudemeOf(supers.get(superPath));
}
}
}
//-------------------------------------------------------------------------
/**
* Set ludeme type for each symbol.
*/
private void setAtomicLudemes()
{
// public static final String[][] Primitives =
// {
// { "int", "game.functions.ints" },
// };
//
// /** Predefined symbols (known data types) with notional and actual package names, and keyword. */
// public static final String[][] Predefined =
// {
// { "java.lang.Integer", "game.functions.ints", "java.lang", "int" },
// };
//
// /** Function names and associated constants. */
// private final String[][] Functions =
// {
// { "IntFunction", "int" },
// { "IntConstant", "int" },
// };
//
// /** Application constants. */
// public final static String[][] ApplicationConstants =
// {
// { "Off", "int", "global", ("" + Constants.OFF) },
// };
for (final Symbol symbol : symbols)
{
// 1. Set symbol as its own atomic symbol (unless proven otherwise)
symbol.setAtomicLudeme(symbol);
// 2. Primitives already remap to correct atomic ludeme
// Do nothing.
// 3. Remap predefined types
if (symbol.name().equals("String"))
continue; // special case
boolean found = false;
for (int n = 0; n < Predefined.length; n++)
if (symbol.cls().getName().equals(Predefined[n][0]))
{
// Is a predefined type
// System.out.println("Predefined type " + symbol.name() + "...");
// System.out.println("- return type is " + symbol.returnType());
final List<Symbol> to = this.symbolsByName.get(Predefined[n][3]);
if (to != null && to.size() >= 1)
{
// System.out.println(to.size( ) + " symbols found:");
// for (final Symbol st : to)
// System.out.println("-- " + st.name());
symbol.setAtomicLudeme(to.get(0));
found = true;
break;
}
//System.out.println("- return type is " + symbol.returnType());
}
if (found)
continue;
// 4. Remap functions
found = false;
for (int n = 0; n < Functions.length; n++)
if (symbol.name().equals(Functions[n][0]))
{
// Is a function
// System.out.println("Function type " + symbol.name() + "...");
// System.out.println("- return type is " + symbol.returnType());
symbol.setAtomicLudeme(symbol.returnType());
found = true;
break;
}
if (found)
continue;
// 5. Remap application constants
found = false;
for (int n = 0; n < ApplicationConstants.length; n++)
if
(
symbol.name().equals(ApplicationConstants[n][0])
&&
symbol.returnType().name().equals("int")
)
{
// Is a function
// System.out.println("Application constant " + symbol.name() + "...");
// System.out.println("- return type is " + symbol.returnType());
final List<Symbol> to = this.symbolsByName.get(ApplicationConstants[n][0]);
for (final Symbol st : to)
{
// System.out.println("-- " + st.name() + " (" + st.cls().getName() + ")");
if (!st.cls().getName().equals("int"))
continue; // only match to int type
// System.out.println("* Match *");
symbol.setAtomicLudeme(st);
found = true;
break;
}
}
if (found)
continue;
}
}
//-------------------------------------------------------------------------
/**
* @return List of ludemes used in grammar, with relevant info.
*/
public List<LudemeInfo> ludemesUsed()
{
// **
// ** Note: Assumes that simplest forms of ludemes are listed first!
// **
// ** e.g. boolean, Boolean, BooleanConstant and BooleanFunction
// ** will all reduce to first occurrence (boolean).
// **
// ** But different OS and/or Java version may list items in different order!
// **
final List<LudemeInfo> ludemesUsed = new ArrayList<>();
for (final Symbol symbol : symbols)
{
// if (symbol.path().equals("game.functions.booleans.math.Equals"))
// System.out.println("Equals...");
if (!symbol.usedInGrammar())
{
//System.out.println("Skipping: " + symbol.token() + " (" + symbol.cls().getName() + ")");
continue;
}
if (symbol.usedInMetadata() && !symbol.name().equals("String"))
continue;
// if (symbol.path().equals("game.functions.booleans.math.Equals"))
// System.out.println("A");
//symbol.usedInMetadata()
//||
//symbol.ludemeType() == LudemeType.SubLudeme
//||
//IncludeInGrammar.class.isAssignableFrom(symbol.cls())
// Check if symbol class has @Hide annotation
// boolean isHide = false;
// final Annotation[] annotations = symbol.cls().getAnnotations();
// for (int a = 0; a < annotations.length && !isHide; a++)
// if (annotations[a].annotationType().getName().equals("annotations.Hide"))
// isHide = true;
// if (isHide)
if (symbol.hidden())
{
//System.out.println("Skipping hidden ludeme class: " + symbol.name());
continue;
}
if
(
symbol.name().equals("Integer")
||
symbol.name().equals("Boolean")
||
symbol.name().equals("Float")
)
continue;
// if (symbol.path().equals("game.functions.booleans.math.Equals"))
// System.out.println("B");
if (symbol.ludemeType() != LudemeType.Constant)
{
// Check whether symbol is already present.
//
// We don't want to do this for constants, as we can
// legitimately have more than one constant with the
// same grammar label, e.g. All in RelationType, RoleType, etc.
//
boolean present = false;
for (final LudemeInfo used : ludemesUsed)
//if (used.symbol().token().equals(symbol.token()))
if (used.symbol().grammarLabel().equals(symbol.grammarLabel()))
{
present = true;
break;
}
if (present)
continue; // don't add duplicates, e.g. boolean/Boolean/BooleanConstant/BooleanFunction, etc.
}
// if (symbol.path().equals("game.functions.booleans.math.Equals"))
// System.out.println("C");
final LudemeInfo ludeme = new LudemeInfo(symbol);
// TODO: Add relevant info here: database id, JavaDoc help, etc.
ludemesUsed.add(ludeme);
}
// System.out.println("\n==================================\nLudemes used:");
// for (final LudemeInfo li : ludemesUsed)
// System.out.println(li.symbol().info());
return ludemesUsed;
}
//-------------------------------------------------------------------------
// /**
// * @return Set containing class names of all official ludemes.
// */
// public Set<String> ludemeNamesUsed()
// {
// final Set<String> set = new HashSet<String>();
//
// final List<LudemeInfo> ludemesUsed = ludemesUsed();
// for (final LudemeInfo ludeme : ludemesUsed)
// set.add(ludeme.symbol().cls().getName());
//
// return set;
// }
//-------------------------------------------------------------------------
/**
* Find ancestors of each symbol.
*/
private void findAncestors()
{
// Make symbol superclasses ancestors
for (final Symbol symbol : symbols)
{
Class<?> parent = symbol.cls();
while (true)
{
parent = parent.getSuperclass();
if (parent == null)
break;
final Symbol parentSymbol = findSymbolByPath(parent.getName());
if (parentSymbol == null)
break;
symbol.addAncestor(parentSymbol);
//System.out.println("Adding ancestor " + parentSymbol.name() + " to " + symbol.name() + ".");
}
}
// Set return type as ancestor (if not already present).
// This will catch enums in super ludeme enum parameter types, but not all ancestors of parent.
for (final Symbol symbol : symbols)
{
final Symbol parentSymbol = symbol.returnType();
if (parentSymbol == null)
continue;
if (parentSymbol.path().equals(symbol.path()))
continue; // symbol returns its own type
// Add parent symbol and its ancestors to current symbol
symbol.addAncestor(parentSymbol);
symbol.addAncestorsFrom(parentSymbol);
}
// Make super ludemes ancestors of their enum parameter types
for (final Symbol symbol : symbols)
{
final Symbol parentSymbol = symbol.subLudemeOf();
if (parentSymbol != null)
{
// Add parent symbol and its ancestors to current symbol
symbol.addAncestor(parentSymbol);
symbol.addAncestorsFrom(parentSymbol); // do we want to include ancestors of super ludeme?
}
}
// Set return type as ancestor (if not already present).
// Repeat to catch all ancestors of enums in super ludeme enum parameter types.
for (final Symbol symbol : symbols)
{
final Symbol returnSymbol = symbol.returnType();
if (returnSymbol == null)
continue;
if (returnSymbol.path().equals(symbol.path()))
continue; // symbol returns its own type
// Need to get actual symbol from the master list,
// as returnType() may be a duplicate (don't know why).
final Symbol parentSymbol = findSymbolByPath(returnSymbol.path());
// Add parent symbol and its ancestors to current symbol
symbol.addAncestor(parentSymbol);
symbol.addAncestorsFrom(parentSymbol);
}
// final Symbol is = findSymbolByPath("game.functions.booleans.is.Is");
// final Symbol isLineType = findSymbolByPath("game.functions.booleans.is.IsLineType");
// final Symbol line = findSymbolByPath("game.functions.booleans.is.IsLineType.Line");
// System.out.println("Line return type: " + line.returnType());
//
// System.out.println("Ancestors of Is: " + is.ancestors());
// System.out.println("Ancestors of IsLineType: " + isLineType.ancestors());
// System.out.println("Ancestors of Line: " + line.ancestors());
//
// System.out.println("IsLineType is type: " + isLineType.ludemeType());
// System.out.println("IsLineType is subludeme of: " + isLineType.subLudemeOf());
//
// System.out.print("Paths for Is are:");
// for (final Symbol symbol : symbolsByName("Is"))
// System.out.println(" " + symbol.path());
// System.out.println();
//
// System.out.print("Paths for IsLineType are:");
// for (final Symbol symbol : symbolsByName("IsLineType"))
// System.out.println(" " + symbol.path());
// System.out.println();
//
// System.out.print("Paths for Line are:");
// for (final Symbol symbol : symbolsByName("Line"))
// System.out.println(" " + symbol.path());
// System.out.println();
}
//-------------------------------------------------------------------------
/**
* @return Symbol details for debugging.
*/
public String symbolDetails()
{
final StringBuilder sb = new StringBuilder();
sb.append("\n+++++++++++++++++++ SYMBOLS ++++++++++++++++++++++\n");
for (final Symbol symbol : symbols)
sb.append(symbol.info() + "\n");
sb.append("\n\n++++++++++++++++++++ RULES +++++++++++++++++++++++\n");
for (final GrammarRule rule : getRules())
sb.append
(
(rule.lhs().usedInGrammar() ? "g" : "~") +
(rule.lhs().usedInDescription() ? "d" : "~") +
(rule.lhs().usedInMetadata() ? "m" : "~") +
" " + rule +
" [" + rule.lhs().cls().getName() + "] " +
"\n"
);
FileHandling.saveStringToFile(sb.toString(), "symbol-details.txt", "");
return(sb.toString());
}
//-------------------------------------------------------------------------
/**
* @return List of grammar rules.
*/
public List<GrammarRule> getRules()
{
return rules;
}
/**
* @return Function labels.
*/
public String[][] getFunctions()
{
return Functions;
}
//-------------------------------------------------------------------------
public String aliases()
{
final StringBuilder sb = new StringBuilder();
for (final Symbol symbol : symbols)
if (symbol.hasAlias())
sb.append(symbol.name() + " (" + symbol.path() + ") has alias: " + symbol.token() + "\n");
return sb.toString();
}
//-------------------------------------------------------------------------
@Override
public String toString()
{
final StringBuilder sb = new StringBuilder();
for (final PackageInfo pack : packageOrder)
sb.append(pack.toString());
return sb.toString();
}
//-------------------------------------------------------------------------
}
| 81,192 | 25.8762 | 111 |
java
|
Ludii
|
Ludii-master/Language/src/parser/Expander.java
|
package parser;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import exception.UnusedOptionException;
import main.FileHandling;
import main.StringRoutines;
import main.grammar.Define;
import main.grammar.DefineInstances;
import main.grammar.Description;
import main.grammar.Report;
import main.options.Option;
import main.options.OptionArgument;
import main.options.OptionCategory;
import main.options.Ruleset;
import main.options.UserSelections;
//-----------------------------------------------------------------------------
/**
* Expands raw user game description (.lud) into full game description with
* defines, options, rulesets and ranges realised for compilation.
*
* @author cambolbro
*/
public class Expander
{
private static final int MAX_EXPANSIONS = 1000;
private static final int MAX_CHARACTERS = 1000000;
private static final int MAX_RANGE = 1000;
private static final int MAX_DEFINE_ARGS = 20;
/** Placeholder character for null define parameters, e.g. ("Jump" ~ (from) ~ ~) */
public static final String DEFINE_PARAMETER_PLACEHOLDER = "~";
//-------------------------------------------------------------------------
/**
* Private constructor; don't allow class to be constructed.
*/
private Expander()
{
}
//-------------------------------------------------------------------------
/**
* Expands options and defines in user string to give full description. Pre:
* userDescription has already been set. Post: Result is stored in
* gameDescription.
*
* @param description The description.
* @param userSelections The user selections.
* @param report The report.
* @param isVerbose True if this is verbose.
*/
public static void expand
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean isVerbose
)
{
if (isVerbose)
{
//System.out.println("+++++++++++++++++++++\nExpanding:\n" + description.raw());
report.addLogLine("+++++++++++++++++++++\nExpanding:\n" + description.raw());
}
String str = new String(description.raw());
// Remove comments before any expansions
str = removeComments(str);
checkDefineCase(str, report);
// Must realise options before expanding defines -- not sure why
str = realiseOptions(str, description, userSelections, report);
if (report.isError())
return;
str = realiseRulesets(str, description, report);
if (report.isError())
return;
// // Store interim result as the "options expanded" description
// String strOptions = cleanUp(str, report);
// if (report.isError())
// return;
//
// final int c = strOptions.indexOf("(metadata");
// if (c >= 0)
// {
// // Remove metadata
// strOptions = strOptions.substring(0, c).trim();
// }
//
// System.out.println("strOptions expanded:\n" + strOptions);
//
// tokenise(strOptions, description, report, isVerbose);
// description.setOptionsExpanded(new String(description.tokenForest().toString())); // format tokens nicely
//
// System.out.println("Options expanded:\n" + description.optionsExpanded());
// Continue expanding defines for full description
str = expandDefines(str, report, description.defineInstances());
if (report.isError())
return;
// Do again after expanding defines, as external defines could have comments
str = removeComments(str);
// Do after expanding defines, as external defines could have ranges
str = expandRanges(str, report);
if (report.isError())
return;
str = expandSiteRanges(str, report);
if (report.isError())
return;
// Do metadata string extraction here rather than in compiler,
// as the metadata text needs defines and options expanded.
// Result is stored in expandedMetadataString.
str = extractMetadata(str, description, userSelections, report);
if (report.isError())
return;
str = cleanUp(str, report);
if (report.isError())
return;
if (isVerbose)
{
//System.out.println("Cleaned up:\n" + str);
report.addLogLine("Cleaned up:\n" + str);
}
// Tokenise expanded string to get full description
if (str == null || str.trim().isEmpty())
str = description.metadata(); // no game description, try tokenising metadata instead
tokenise(str, description, report, isVerbose);
// System.out.println("Token errors = " + report.isError());
description.setExpanded(new String(description.tokenForest().toString())); // format tokens nicely
// System.out.println(description.tokenTree().dump(""));
}
//-------------------------------------------------------------------------
public static String cleanUp(final String strIn, final Report report)
{
String str = strIn;
// Remove unneeded internal spaces
str = str.replaceAll("\n", " ");
str = str.replaceAll("\r", " ");
str = str.replaceAll("\t", " ");
while (str.contains(" "))
str = str.replaceAll(" ", " ");
while (str.contains(" "))
str = str.replaceAll(" ", " ");
str = str.replaceAll(" \\)", "\\)"); // regex doesn't like ")"
str = str.replaceAll("\\( ", "\\("); // regex doesn't like "("
str = str.replaceAll(" \\}", "\\}");
str = str.replaceAll("\\{ ", "\\{");
while (str.contains(": "))
str = str.replaceAll(": ", ":");
// // Hack so that ItemCount() objects don't need to be be named.
// // Do this AFTER all defines have been expanded!
// str = str.replaceAll("\\(\"", "\\(itemCount \"");
str = handleDoubleBrackets(str, report); // do this after reducing spaces
if (report != null && report.isError())
return null;
return str;
}
//-------------------------------------------------------------------------
/**
* Create token tree from the specified (expanded) string.
*
* @param str The string.
* @param description The description.
* @param report The report.
* @param isVerbose True if this is verbose.
*/
public static void tokenise
(
final String str,
final Description description,
final Report report,
final boolean isVerbose
)
{
//description.setTokenTree(new Token(str, report));
description.tokenForest().populate(str, report);
if (isVerbose)
{
//System.out.println("\nToken tree:\n" + description.tokenForest().tokenTree());
report.addLogLine("\nToken tree:\n" + description.tokenForest().tokenTree());
}
if
(
description.tokenForest().tokenTree() == null
||
description.tokenForest().tokenTree().type() == null
)
{
//System.out.println(description.tokenTree());
//throw new CantDecomposeException("Expander.tokenise()");
report.addError("Expander can't tokenise the game description.");
return; // not necessary but good practice
}
}
//-------------------------------------------------------------------------
/**
* Check for lowercase define labels.
*/
public static void checkDefineCase(final String str, final Report report)
{
// System.out.println(str);
int c = 0;
while (true)
{
c = str.indexOf("(define \"", c);
if (c < 0)
break;
final char ch = str.charAt(c + 9);
if (!Character.isUpperCase(ch))
{
// First char in define is not an uppercase letter
int cc = c + 9;
while (cc < str.length() && StringRoutines.isTokenChar(str.charAt(cc)))
cc++;
final String name = str.substring(c+9, cc);
final String msg = "Lowercase define name \"" + name + ".";
report.addLogLine(msg);
report.addWarning(msg);
report.addNote(msg);
//report.addError(msg);
System.out.println(msg);
}
c++;
}
}
//-------------------------------------------------------------------------
/**
* Handle double brackets.
* These will typically occur when a bracketed ("Define") is expanded.
* @return Game description with double brackets removed.
*/
private static String handleDoubleBrackets
(
final String strIn,
final Report report
)
{
if (!strIn.contains("(("))
return new String(strIn); // nothing to do
String str = new String(strIn);
while (true)
{
final int c = str.indexOf("((");
if (c < 0)
break; // all done
final int cc = StringRoutines.matchingBracketAt(str, c);
if (cc < 0 || cc >= str.length())
{
//throw new UnclosedClauseException(str.substring(c));
if (report != null)
report.addError("Couldn't close clause '" + Report.clippedString(str.substring(c), 20) + "'.");
return null;
}
if (str.charAt(cc) == ')' && str.charAt(cc-1) == ')')
{
// Remove outer brackets (front and back)
str = str.substring(0, cc) + str.substring(cc+1); // remove trailing duplicates
str = str.substring(0, c) + str.substring(c+1); // remove leading duplicates
}
else
{
// Opening pair do not have closing pair, should never occur
if (report != null)
report.addError("Opening bracket pair '((' in '" + Report.clippedString(str.substring(c), 20) + "' does not have closing pair.");
return null;
}
}
return str;
}
//-------------------------------------------------------------------------
/**
* Realise options.
* @return Game description with defines expanded in-place.
*/
public static String realiseOptions
(
final String strIn,
final Description description,
final UserSelections userSelections,
final Report report
)
{
description.gameOptions().clear();
if (!strIn.contains("(option \""))
return new String(strIn); // nothing to do
String str = new String(strIn);
str = extractOptions(str, description, report);
if (report.isError() || str == null)
return null;
int[] optionSelections;
try
{
optionSelections = description.gameOptions().computeOptionSelections(userSelections.selectedOptionStrings());
}
catch (final UnusedOptionException e)
{
// Revert to default options for this game
//e.printStackTrace();
System.err.println("Reverting to default options for game due to unrecognised option being specified!");
userSelections.setSelectOptionStrings(new ArrayList<String>());
optionSelections = description.gameOptions().computeOptionSelections(userSelections.selectedOptionStrings());
}
// Expand the user-selected choice (or default) in each option group
for (int cat = 0; cat < description.gameOptions().numCategories(); cat++)
{
final OptionCategory category = description.gameOptions().categories().get(cat);
if (category.options().size() > 0)
{
final Option option = category.options().get(optionSelections[cat]);
if (option.arguments().isEmpty())
{
// Can be valid if options are being used to define headings in the metadata
return str;
}
str = expandOption(str, option, report);
if (report.isError() || str == null)
return null;
}
}
return str;
}
//-------------------------------------------------------------------------
/**
* Stores a copy of each option and removes their definition from the game description.
* @return Game description with options removed and stored in list.
*/
private static final String extractOptions
(
final String strIn,
final Description description,
final Report report
)
{
// Extracts options in this format:
//
// (option "Board Size" <Size> args:{ <dim> <start> <end> }
// {
// ("3x3" <3 3> <9> <4> "Played on a square 3x3 board.")
// ("4x4" <4 4> <16> <8> "Played on a square 4x4 board.")*
// ("5x5" <5 5> <25> <12> "Played on a square 5x5 board.")**
// }
// )
String str = new String(strIn);
while (str.contains("(option \""))
{
final int c = str.indexOf("(option \"");
// Find matching closing bracket
int cc = StringRoutines.matchingBracketAt(str, c);
if (cc < 0 || cc >= str.length())
{
//throw new UnclosedClauseException(str.substring(c));
report.addError("Couldn't close clause '" + Report.clippedString(str.substring(c), 20) + "'.");
return null;
}
cc++;
final OptionCategory category = new OptionCategory(str.substring(c, cc));
// Check whether option args are well formed, e.g. "Step/hop move" is a bad label
for (final Option option : category.options())
{
for (final String header : option.menuHeadings())
if (header.contains("/"))
{
report.addError("Bad '/' in option header \"" + header + "\".");
return null;
}
}
description.gameOptions().add(category);
str = str.substring(0, c) + str.substring(cc); // remove from source string
}
return str;
}
//-------------------------------------------------------------------------
/**
* @param strIn
* @return Game description with all occurrences of option expanded.
*/
private static String expandOption
(
final String strIn,
final Option option,
final Report report
)
{
String str = new String(strIn);
// Pass 1: Match all <Category:arg> instances first
for (final OptionArgument arg : option.arguments())
{
final String name = arg.name();
if (name == null)
{
//throw new IllegalArgumentException("Some option arguments are named but this one is not.");
report.addError("Some option arguments are named but this one is not.");
return null;
}
final String marker = "<" + option.tag() + ":" + name + ">";
int iterations = 0;
while (str.contains(marker))
{
if (++iterations > MAX_EXPANSIONS)
{
//throw new InvalidOptionException("An option has more than " + MAX_EXPANSIONS + " expansions.");
report.addError("An option has more than " + MAX_EXPANSIONS + " expansions.");
return null;
}
if (str.length() > MAX_CHARACTERS)
{
//throw new InvalidOptionException("The option " + option.toString() + " has more than " + MAX_CHARACTERS + " characters.");
report.addError("The option " + option.toString() + " has more than " + MAX_CHARACTERS + " characters.");
return null;
}
// Expand this instance in-place
final int c = str.indexOf(marker);
str = str.substring(0, c) + arg.expression() + str.substring(c + marker.length());
}
}
// **
// ** Don't do this test: rulesets can have primary tags without secondary tags!
// **
// // Check that author didn't forget to use names in instances.
// final String marker = "<" + option.label() + ">";
// if (str.contains(marker))
// {
// System.out.println("Marker " + marker + " but named markers expected, in: " + str);
// throw new InvalidOptionException("Option <label> should be in <label:name> format.");
// }
// Pass 2: Expand instances with <Category> as arg 0 (was modulus order)
final String marker = "<" + option.tag() + ">";
// final int numArgs = option.arguments().size();
// int count = 0;
int iterations = 0;
while (str.contains(marker))
{
if (++iterations > MAX_EXPANSIONS)
{
//throw new InvalidOptionException("An option has more than " + MAX_EXPANSIONS + " expansions.");
report.addError("An option has more than " + MAX_EXPANSIONS + " expansions.");
return null;
}
if (str.length() > MAX_CHARACTERS)
{
//throw new InvalidOptionException("The option " + option.toString() + " has more than " + MAX_CHARACTERS + " characters.");
report.addError("The option " + option.toString() + " has more than " + MAX_CHARACTERS + " characters.");
return null;
}
// Expand this instance in-place
final int c = str.indexOf(marker);
final int index = 0; //count++ % numArgs;
str = str.substring(0, c) + option.arguments().get(index).expression() + str.substring(c + marker.length());
}
return str;
}
//-------------------------------------------------------------------------
/**
* Realise rulesets.
*/
public static String realiseRulesets
(
final String strIn,
final Description description,
final Report report
)
{
if (!strIn.contains("(rulesets"))
return strIn; // nothing to do
final String str = extractRulesets(strIn, description, report);
return str;
}
/**
* Stores a copy of each ruleset and removes their definition from the game description.
* @return Game description with rulesets removed and stored in list.
*/
private static final String extractRulesets
(
final String strIn,
final Description description,
final Report report
)
{
description.clearRulesets();
String str = new String(strIn);
int c = str.indexOf("(rulesets");
if (c < 0)
{
//throw new BadSyntaxException("Rulesets not found.", str);
report.addError("Rulesets not found.");
return null;
}
int cc = StringRoutines.matchingBracketAt(str, c);
if (cc < 0)
{
//throw new BadSyntaxException("No closing bracket ')' in rulesets.", str);
report.addError("No closing bracket ')' in rulesets '" + Report.clippedString(str.substring(c), 20) + "'.");
return null;
}
String rulesetsStr = str.substring(c+8, cc-1).trim();
str = str.substring(0, c) + str.substring(cc); // remove rulesets from game description
// Process this rulesets string
while (true)
{
c = rulesetsStr.indexOf("(ruleset ");
if (c < 0)
break; // no more rulesets
cc = StringRoutines.matchingBracketAt(rulesetsStr, c);
if (cc < 0)
{
//throw new BadSyntaxException("No closing bracket ')' in ruleset.", rulesetsStr);
report.addError("No closing bracket ')' in ruleset '" + Report.clippedString(rulesetsStr.substring(c), 20) + "'.");
return null;
}
String rulesetStr = rulesetsStr.substring(c, cc+1);
int priorityIndex = cc + 1;
while (priorityIndex < rulesetsStr.length() && rulesetsStr.charAt(priorityIndex) == '*')
{
rulesetStr += '*'; // preserve priority markers
priorityIndex++;
}
final Ruleset ruleset = new Ruleset(rulesetStr);
description.add(ruleset);
rulesetsStr = rulesetsStr.substring(cc+1);
}
// Just delete any remaining rulesets in the game description
while (true)
{
c = str.indexOf("(rulesets");
if (c < 0)
break; // no more rulesets
cc = StringRoutines.matchingBracketAt(str, c);
if (cc < 0)
{
//throw new BadSyntaxException("No closing bracket ')' in extra rulesets.", str);
report.addError("No closing bracket ')' in extra rulesets '" + Report.clippedString(str.substring(c), 20) + "'.");
return null;
}
str = str.substring(0, c) + str.substring(cc); // remove this extra set of rulesets
}
return str;
}
//-------------------------------------------------------------------------
/**
* Expand defines iteratively until no more expansions occur.
*/
public static String expandDefines
(
final String strIn,
final Report report,
final Map<String, DefineInstances> defineInstances
)
{
// Load game AI metadata define (if any)
final Define knownAIDefine = loadKnownAIDefine(strIn, report);
if (report.isError())
return null;
// Expand defines
int defineIterations = 0;
String str = strIn;
while (true)
{
final String strDef = expandDefinesPass(str, knownAIDefine, report, defineInstances);
if (report.isError())
return null;
if (str.equals(strDef))
break; // no more defines
str = strDef;
if (++defineIterations > MAX_EXPANSIONS || str.length() > MAX_CHARACTERS)
{
// Probably an infinite loop, e.g. (define "A" "B") (define "B" "A")
//throw new DefineExpansionException("A suspected infinitely recursive define.");
report.addError("Suspected infinitely recursive define.");
return null;
}
}
return str;
}
/**
* Expand current set of defines, which may expand into more defines.
*/
private static String expandDefinesPass
(
final String strIn,
final Define knownAIDefine,
final Report report,
final Map<String, DefineInstances> defineInstances
)
{
final List<Define> defines = new ArrayList<>();
final Map<String, Define> knownDefines = KnownDefines.getKnownDefines().knownDefines();
String str = extractDefines(strIn, defines, report);
if (report.isError())
return null;
// Repeatedly: expand in-file defines as thoroughly as possible,
// then all predefined defines as thoroughly as possible.
boolean didExpandAny;
do
{
didExpandAny = false;
// First, expand all in-file defines as thoroughly as possible
final boolean[] didExpand = new boolean[1];
do
{
didExpand[0] = false;
for (final Define def : defines)
{
if (str.contains(def.tag()))
{
str = expandDefine(str, def, didExpand, report, defineInstances);
if (report.isError())
return null;
}
}
if (didExpand[0])
didExpandAny = true;
} while (didExpand[0]);
// Secondly, expand all predefined defines as thoroughly as possible except in the metadata
String metadata = "";
final int c = str.indexOf("(metadata");
if (c >= 0)
{
metadata = str.substring(c, StringRoutines.matchingBracketAt(str, c) + 1);
str = str.substring(0, c);
}
do
{
didExpand[0] = false;
for (final Map.Entry<String, Define> entry : knownDefines.entrySet())
{
final Define def = entry.getValue();
if (str.contains(def.tag()))
{
str = expandDefine(str, def, didExpand, report, defineInstances);
if (report.isError())
return null;
}
}
if (didExpand[0])
didExpandAny = true;
} while (didExpand[0]);
str = str + metadata;
// Thirdly, expand known game AI metadata define (if found)
if (knownAIDefine != null)
{
if (str.contains(knownAIDefine.tag()))
{
didExpand[0] = false;
str = expandDefine(str, knownAIDefine, didExpand, report, defineInstances);
if (report.isError())
return null;
if (didExpand[0])
didExpandAny = true;
}
}
} while (didExpandAny);
return str;
}
/**
* Stores a copy of each define and removes their definition from the game description.
* @param strIn
* @return Game description with defines removed and stored in list.
*/
public static String extractDefines
(
final String strIn,
final List<Define> defines,
final Report report
)
{
final int[] extent = new int[2]; // char indices of opening and closing brackets
String str = new String(strIn);
while (str.contains("(define "))
{
final Define define = interpretDefine(str, extent, report, false);
if (report != null && report.isError())
return null;
if (define == null)
{
System.out.println("** Failed to load define:\n" + str);
continue;
}
defines.add(define);
str = str.substring(0, extent[0]) + str.substring(extent[1]+1);
}
return str;
}
/**
* @param str
* @param extent
* @param report
*
* @return The real define.
*/
public static Define interpretDefine
(
final String str,
final int[] extent,
final Report report,
final boolean isKnown
)
{
// 1. Remove opening and closing brackets
int c = str.indexOf("(define ");
if (c < 0)
return null; // not a define
final int cc = StringRoutines.matchingBracketAt(str, c);
if (cc < 0)
{
// System.out.println("** Bad define string: " + str);
// throw new BadSyntaxException("define", "Badly formed define. Should start and end with `(define' and end with a bracket.");
if (report != null)
report.addError("Could not close '(define ...' in '" + Report.clippedString(str.substring(c), 20) + "'.");
return null;
}
String desc = str.substring(c+1, cc).trim();
if (extent != null)
{
// Store extent of define (char indices of opening and closing brackets)
extent[0] = c;
extent[1] = cc;
}
// 2. Remove header '(define "name"' which contains two quotes
c = 0;
int numQuotes = 0;
while (c < desc.length())
{
if (desc.charAt(c) == '"')
numQuotes++;
if (numQuotes >= 2)
break;
c++;
}
if (numQuotes < 2)
{
// throw new BadSyntaxException("define", "Badly formed define. Should be start (define \"name\".");
if (report != null)
report.addError("Badly fomred '(define \"name\"...' in '" + Report.clippedString(desc, 20) + "'.");
return null;
}
// Find the label for the define (first String in quotes)
final int openingQuoteIdx = desc.indexOf("\"");
final int closingQuoteIdx = desc.indexOf("\"", openingQuoteIdx + 1);
final String key = desc.substring(openingQuoteIdx, closingQuoteIdx + 1);
desc = desc.substring(c+1).trim();
final Define define = new Define(key, desc, isKnown);
//System.out.println("Define is: " + define);
return define;
}
/**
* @param strIn
* @return Game description with all occurrences of define expanded.
*/
private static String expandDefine
(
final String strIn,
final Define define,
final boolean[] didExpand,
final Report report,
final Map<String, DefineInstances> defineInstances
)
{
String str = new String(strIn);
// System.out.println("Expanding define: " + define.tag() + "...");
final int len = define.tag().length();
int iterations = 0;
int c = 0;
while (true)
{
if (++iterations > MAX_EXPANSIONS)
{
// throw new DefineExpansionException("A define has more than " + MAX_EXPANSIONS + " expansions.");
report.addError("Define has more than " + MAX_EXPANSIONS + " expansions '" + Report.clippedString(str, 20) + "'.");
return null;
}
if (str.length() > MAX_CHARACTERS)
{
// throw new DefineExpansionException("A define has more than " + MAX_CHARACTERS + " characters.");
report.addError("Define has more than " + MAX_CHARACTERS + " characters '" + Report.clippedString(str, 20) + "'.");
return null;
}
// Check for next occurrence of define label
c = str.indexOf(define.tag(), c+1);
if (c == -1)
break; // no more occurrences
if (protectedSubstring(str, c))
{
// Protected substring found
continue;
}
int cc = c + len-1; // if no brackets
if (str.charAt(c-1) == '(')
{
// Take brackets into account
c--;
cc = StringRoutines.matchingBracketAt(str, c);
if (cc < 0 || cc >= str.length())
{
// throw new BadSyntaxException("define", "Failed to handle parameter in define.");
report.addError("Failed to handle parameter in define '" + Report.clippedString(str.substring(c), 20) + "'.");
return null;
}
}
final String argString = str.substring(c, cc+1).trim();
final List<String> args = extractDefineArgs(argString, report);
if (report.isError())
return null;
final String exprn = expandDefineArgs(define, args, report);
if (report.isError())
return null;
if (defineInstances != null)
{
// Add this expression to the relevant DefineInstances record
DefineInstances defIn = defineInstances.get(define.tag());
if (defIn == null)
{
defIn = new DefineInstances(define);
defineInstances.put(define.tag(), defIn);
}
defIn.addInstance(new String(exprn));
}
// Do the expansion
str = str.substring(0, c) + exprn + str.substring(cc+1);
didExpand[0] = true;
}
str = str.replace("<DELETE_ME>", ""); // remove null parameter placeholders
return str;
}
//-------------------------------------------------------------------------
private static final List<String> extractDefineArgs
(
final String argString,
final Report report
)
{
final List<String> args = new ArrayList<String>();
String str = new String(argString.trim());
if (str.charAt(0) == '(')
{
final int cc = StringRoutines.matchingBracketAt(str, 0);
if (cc == -1)
{
// throw new BadSyntaxException("define", "Failed to read bracketed clause from: " + str + ".");
report.addError("Failed to read bracketed clause '(...)' from '" + Report.clippedString(str, 20) + "'.");
return null;
}
str = str.substring(1, cc);
}
// Move to first arg after label
int a = 0;
while (a < str.length() && !Character.isWhitespace(str.charAt(a)))
a++;
if (a >= str.length())
return args; // no arguments
str = str.substring(a).trim();
while (!str.isEmpty())
{
// Extract next parameter from head of list
int aTo = 0;
if (StringRoutines.isOpenBracket(str.charAt(0)))
{
// Read in bracketed clause
aTo = StringRoutines.matchingBracketAt(str, 0);
if (aTo == -1)
{
// throw new BadSyntaxException("define", "Failed to read bracketed clause from: " + str + ".");
report.addError("Failed to read bracketed clause from '" + Report.clippedString(str, 20) + "'.");
return null;
}
aTo++; // step past closing bracket
}
else if (str.charAt(0) == '"')
{
// Read in named bracketed clause
aTo = StringRoutines.matchingQuoteAt(str, 0);
if (aTo == -1)
{
// throw new BadSyntaxException("define", "Failed to read quoted clause \"...\" from: " + str + ".");
report.addError("Failed to read quoted clause '\"...\"' from '" + Report.clippedString(str, 20) + "'.");
return null;
}
aTo++; // step past closing bracket
}
else
{
// Read in next symbol
aTo = 0;
while (aTo < str.length() && !Character.isWhitespace(str.charAt(aTo)))
{
if (str.charAt(aTo) == ':')
{
// Named parameter, check if remaining of expression is bracketed
if (StringRoutines.isOpenBracket(str.charAt(aTo+1)))
{
aTo = StringRoutines.matchingBracketAt(str, aTo+1);
if (aTo == -1)
{
// throw new BadSyntaxException("define", "Failed to read bracketed clause '{...}' from: " + str + ".");
report.addError("Failed to read bracketed clause '{...}' from '" +
Report.clippedString(str, 20) + "'.");
return null;
}
aTo++; // step past closing bracket
break;
}
}
aTo++;
}
}
if (aTo >= str.length())
aTo = str.length();
final String arg = str.substring(0, aTo);
args.add(new String(arg));
str = str.substring(aTo).trim();
}
return args;
}
private static String expandDefineArgs
(
final Define define,
final List<String> args,
final Report report
)
{
String exprn = new String(define.expression());
for (int n = 0; n < MAX_DEFINE_ARGS; n++)
{
final String marker = "#" + (n+1);
if (!exprn.contains(marker))
break; // no more args
int innerIterations = 0;
while (exprn.contains(marker))
{
if (++innerIterations > MAX_EXPANSIONS)
{
// throw new DefineExpansionException("A define has more than " + MAX_EXPANSIONS + " expansions (inner loop).");
report.addError("Define has more than " + MAX_EXPANSIONS + " expansions '" +
Report.clippedString(exprn, 20) + "'.");
return null;
}
if (exprn.length() > MAX_CHARACTERS)
{
// throw new DefineExpansionException("A define has more than " + MAX_CHARACTERS + " characters (inner loop exprn).");
report.addError("Define has more than " + MAX_CHARACTERS + " characters '" +
Report.clippedString(exprn, 20) + "'.");
return null;
}
final int m = exprn.indexOf(marker);
String arg = "<DELETE_ME>"; // mark for deletion
if (n < args.size() && !args.get(n).equals(DEFINE_PARAMETER_PLACEHOLDER))
arg = args.get(n);
exprn = exprn.substring(0, m) + arg + exprn.substring(m+2);
// System.out.println("- expanding exprn: " + exprn);
if (arg.charAt(0) == '#')
break; // arg is an arg itself
}
}
return exprn;
}
//-------------------------------------------------------------------------
/**
* @param str String to check.
* @param fromIndex Index of substring.
* @return Whether the specified substring within str should be protected
* from expansion by a define.
* These include "(game", "(match", "(instance", etc.
*/
public static boolean protectedSubstring
(
final String str,
final int fromIndex
)
{
// Tokens that protect the following string from being expanded as a define,
// in case the string accidentally matches a known define.
final String[] safeTokens = { "game", "match", "instance" };
// Step back to previous token (might be a bracket)
int c = fromIndex-1;
while (c >= 0)
{
if (StringRoutines.isTokenChar(str.charAt(c)))
break;
c--;
}
if (c < 0)
{
System.out.println("** Warning: Failed to find previous token (probably from define).");
System.out.println("** fromIndex=" + fromIndex + ", str:=\n" + str);
return false;
}
// Get token string
String token = "";
while (c >= 0)
{
final char ch = str.charAt(c);
if (!StringRoutines.isTokenChar(ch))
break;
token = ch + token;
c--;
}
if (c < 0)
{
System.out.println("** Warning: Failed to read previous token (probably from define).");
System.out.println("** fromIndex=" + fromIndex + ", str:=\n" + str);
return false;
}
for (final String safeToken : safeTokens)
if (token.equals(safeToken))
return true; // this substring is protected
return false;
}
//-------------------------------------------------------------------------
/**
* Load known AI metadata define from file.
*/
private static Define loadKnownAIDefine
(
final String strIn,
final Report report
)
{
if (!strIn.contains("(ai") || !strIn.contains("_ai"))
return null;
Define knownAIDefine = null;
final String gameName = StringRoutines.gameName(strIn);
String aiName = gameName;
// Check that the ai file name, if any, matches the game name
final int c = strIn.indexOf("_ai\"");
if (c >= 0)
{
int cc = c;
while (cc >= 0 && strIn.charAt(cc) != '"')
cc--;
aiName = strIn.substring(cc + 1, c);
// if (!aiName.equals(gameName))
// {
// report.addWarning("Define '" + aiName + "_ai' found in AI metadata; use '" + gameName + "_ai' or remove it.");
// return Expander.interpretDefine("(define \"" + aiName + "_ai\")", null, report, true);
// }
}
final String[] defs = FileHandling.getResourceListingSingle(Expander.class, "def_ai/", aiName + "_ai.def");
if (defs == null)
{
// Not a JAR
try
{
// Start with known _ai.def file
final URL url = Expander.class.getResource("/def_ai/Chess_ai.def");
String path = new File(url.toURI()).getPath();
path = path.substring(0, path.length() - "Chess_ai.def".length());
final File root = new File(path);
final File[] list = root.listFiles();
if (list == null)
return null;
for (final File file : list)
if
(
file != null
&&
!file.isDirectory()
&&
file.getName() != null
&&
file.getName().equals(aiName + "_ai.def")
)
{
// Found the file
final String filePath = path + file.getName();
knownAIDefine = KnownDefines.processDefFile
(
filePath.replaceAll(Pattern.quote("\\"), "/"),
"/def_ai/",
report
);
if (report.isError())
return null;
}
}
catch (final Exception e)
{
e.printStackTrace();
}
}
else
{
for (String def : defs)
{
def = def.replaceAll(Pattern.quote("\\"), "/");
final String[] defSplit = def.split(Pattern.quote("/"));
final String filename = defSplit[defSplit.length - 1];
if (filename.equals(aiName + "_ai.def"))
{
knownAIDefine = KnownDefines.processDefFile(def, "/def_ai/", report);
if (report.isError())
return null;
}
}
}
if (knownAIDefine == null)
{
knownAIDefine = Expander.interpretDefine("(define \"" + aiName + "_ai\")", null, report, false);
report.addWarning("Failed to load AI define specified in metadata; reverting to default AI.");
}
return knownAIDefine;
}
//-------------------------------------------------------------------------
/**
* @param strIn
* @return Game description with all number range occurrences expanded.
*/
public static String expandRanges
(
final String strIn,
final Report report
)
{
if (!strIn.contains(".."))
return strIn; // nothing to do
String str = new String(strIn);
int ref = 1;
boolean inCompletion = false;
while (ref < str.length() - 2)
{
if(str.charAt(ref) == '[')
inCompletion = true;
if(str.charAt(ref) == ']')
inCompletion = false;
if(!inCompletion)
{
if
(
str.charAt(ref) == '.' && str.charAt(ref+1) == '.'
&&
Character.isDigit(str.charAt(ref-1))
&&
Character.isDigit(str.charAt(ref+2))
)
{
// Is a range: expand it
int c = ref - 1;
while (c >= 0 && Character.isDigit(str.charAt(c)))
c--;
c++;
final String strM = str.substring(c, ref);
final int m = Integer.parseInt(strM);
c = ref + 2;
while (c < str.length() && Character.isDigit(str.charAt(c)))
c++;
final String strN = str.substring(ref+2, c);
final int n = Integer.parseInt(strN);
if (Math.abs(n - m) > MAX_RANGE)
{
//throw new BadRangeException(MAX_RANGE);
report.addError("Range exceeded maximum of " + MAX_RANGE + ".");
return null;
}
// Generate the expanded range substring
String sub = " ";
final int inc = (m <= n) ? 1 : -1;
for (int step = m; step != n; step += inc)
{
if (step == m || step == n)
continue; // don't include end points
sub += step + " ";
}
str = str.substring(0, ref) + sub + str.substring(ref+2);
ref += sub.length();
}
}
ref++;
}
return str;
}
/**
* @param strIn
* @return Game description with all site range occurrences expanded.
*/
public static String expandSiteRanges
(
final String strIn,
final Report report
)
{
if (!strIn.contains(".."))
return strIn; // nothing to do
String str = new String(strIn);
boolean inCompletion = false;
int ref = 1;
while (ref < str.length() - 2)
{
if(str.charAt(ref) == '[')
inCompletion = true;
if(str.charAt(ref) == ']')
inCompletion = false;
if(!inCompletion)
{
if
(
str.charAt(ref) == '.' && str.charAt(ref+1) == '.'
&&
str.charAt(ref-1) == '"' && str.charAt(ref+2) == '"'
)
{
// Must be a site range
int c = ref - 2;
while (c >= 0 && str.charAt(c) != '"')
c--;
final String strC = str.substring(c+1, ref-1);
// System.out.println("strC: " + strC);
int d = ref + 3;
while (d < str.length() && str.charAt(d) != '"')
d++;
d++;
final String strD = str.substring(ref+3, d-1);
// System.out.println("strD: " + strD);
// System.out.println("Range: " + str.substring(c, d));
if (strC.length() < 2 || !StringRoutines.isLetter(strC.charAt(0)))
{
report.addError("Bad 'from' coordinate in site range: " + str.substring(c, d));
return null;
}
final int fromChar = Character.toUpperCase(strC.charAt(0)) - 'A';
if (strD.length() < 2 || !StringRoutines.isLetter(strD.charAt(0)))
{
report.addError("Bad 'to' coordinate in site range: " + str.substring(c, d));
return null;
}
final int toChar = Character.toUpperCase(strD.charAt(0)) - 'A';
// System.out.println("fromChar=" + fromChar + ", toChar=" + toChar + ".");
final int fromNum = Integer.parseInt(strC.substring(1));
final int toNum = Integer.parseInt(strD.substring(1));
// System.out.println("fromNum=" + fromNum + ", toNum=" + toNum + ".");
// Generate the expanded range substring
String sub = "";
for (int m = fromChar; m < toChar + 1; m++)
for (int n = fromNum; n < toNum + 1; n++)
sub += "\"" + (char)('A' + m) + (n) + "\" ";
str = str.substring(0, c) + sub.trim() + str.substring(d);
ref += sub.length();
}
}
ref++;
}
// System.out.println(str);
return str;
}
//-------------------------------------------------------------------------
/**
* Extracts metadata and stores it in expandedMetadataString.
* @param strIn The complete expanded game description.
* @param options The Game options with which we're compiling.
* @return Game description with metadata removed and stored in expandedMetadataString.
*/
private static String extractMetadata
(
final String strIn,
final Description description,
final UserSelections userSelections,
final Report report
)
{
final int c = strIn.indexOf("(metadata");
if (c < 0)
return strIn; // no metadata to extract
// Find matching closing bracket
final int cc = StringRoutines.matchingBracketAt(strIn, c);
if (cc < 0)
{
//throw new BadSyntaxException("metadata", "Failed to close (metadata...");
report.addError("Failed to close '(metadata' in '" +
Report.clippedString(strIn.substring(c), 20) + "'.");
return null;
}
String str = strIn.substring(c, cc+1);
// // Check if next char is '{'
// int b = 9; // skip "(metadata "
// char ch = ' ';
// while (b < str.length())
// {
// ch = str.charAt(b);
// if (ch == '{' || ch == '(' || StringRoutines.isNameChar(ch))
// break;
// b++;
// }
// if (ch == '{')
// {
// final int bb = StringRoutines.matchingBracketAt(str, b);
// str = str.substring(0, b) + str.substring(bb+1);
// }
str = removeUnselectedOptionParts(str, description, userSelections, report);
if (report.isError())
return null;
description.setMetadata(new String(str));
final String removed = strIn.substring(0, c) + strIn.substring(cc+1);
return removed;
}
/**
* Remove parts that require different game options from those selected.
* @return game description with unselected option parts removed.
*/
private static String removeUnselectedOptionParts
(
final String strIn,
final Description description,
final UserSelections userSelections,
final Report report
)
{
String str = new String(strIn);
// First thing we'll do; try to auto-select ruleset based on options if
// we do not already have a selected ruleset
int activeRuleset = userSelections.ruleset();
if (activeRuleset < 0)
{
activeRuleset = description.autoSelectRuleset(userSelections.selectedOptionStrings());
if (activeRuleset >= 0)
userSelections.setRuleset(activeRuleset);
}
final List<String> active = description.gameOptions().allOptionStrings
(
userSelections.selectedOptionStrings()
);
while (true)
{
final int optsCondStartIdx = str.indexOf("(useFor ");
if (optsCondStartIdx < 0)
break; // no more chunks of metadata that are restricted by options
final int optsCondClosingBracketIdx = StringRoutines.matchingBracketAt(str, optsCondStartIdx);
if (optsCondClosingBracketIdx < 0)
{
// throw new BadSyntaxException("metadata", "Failed to close (useFor ...");
report.addError("Failed to close '(useFor' in '" +
Report.clippedString(str.substring(optsCondStartIdx), 20) + "'.");
return null;
}
// Find the substring that specifies all the required rulesets / options
final int requirementsSubstrIdxStart;
final int requirementsSubstrIdxEnd;
final int nextOpeningCurlyIdx = str.indexOf('{', optsCondStartIdx);
final int nextQuoteIdx = str.indexOf('"', optsCondStartIdx);
if (nextQuoteIdx < 0)
{
// throw new BadSyntaxException("metadata", "There must always be a quote somewhere after (useFor ");
report.addError("No quote after '(useFor' in '" +
Report.clippedString(str.substring(optsCondStartIdx), 20) + "'.");
return null;
}
if (nextOpeningCurlyIdx >= 0 && nextOpeningCurlyIdx < nextQuoteIdx)
{
// We have curly braces
final int openCurlyBracketIdx = nextOpeningCurlyIdx;
final int closCurlyBracketIdx = StringRoutines.matchingBracketAt(str, openCurlyBracketIdx);
if (closCurlyBracketIdx < 0)
{
// throw new BadSyntaxException("metadata", "Failed to close curly bracket of (useFor {...");
report.addError("Failed to close curly bracket '{' in '" +
Report.clippedString(str.substring(optsCondStartIdx), 20) + "'.");
return null;
}
requirementsSubstrIdxStart = openCurlyBracketIdx + 1;
requirementsSubstrIdxEnd = closCurlyBracketIdx;
}
else
{
// We don't have curly braces
final int openingQuoteIdx = nextQuoteIdx;
int closingQuoteIdx = str.indexOf('"', openingQuoteIdx + 1);
while (closingQuoteIdx >= 0 && str.charAt(closingQuoteIdx - 1) == '\\')
{
// Escaped quote, so keep moving on
closingQuoteIdx = str.indexOf('"', closingQuoteIdx + 1);
}
if (closingQuoteIdx < 0)
{
//throw new BadSyntaxException("metadata", "Failed to close quote after (useFor \"...");
report.addError("Failed to close quote after '(useFor' in '" +
Report.clippedString(str.substring(openingQuoteIdx), 20) + "'.");
return null;
}
requirementsSubstrIdxStart = openingQuoteIdx;
requirementsSubstrIdxEnd = closingQuoteIdx + 1;
}
// Extract the required options
final List<String> requiredOptions = new ArrayList<String>();
final String requirementsSubstr = str.substring(requirementsSubstrIdxStart, requirementsSubstrIdxEnd);
int requiredOptOpenQuoteIdx = requirementsSubstr.indexOf('"');
while (requiredOptOpenQuoteIdx >= 0)
{
int requiredOptClosingQuoteIdx = requirementsSubstr.indexOf('"', requiredOptOpenQuoteIdx + 1);
while (requirementsSubstr.charAt(requiredOptClosingQuoteIdx - 1) == '\\')
requiredOptClosingQuoteIdx = requirementsSubstr.indexOf('"', requiredOptClosingQuoteIdx + 1);
if (requiredOptClosingQuoteIdx < 0)
{
//throw new BadSyntaxException("metadata", "Failed to close quote of a String in (useFor ...)");
report.addError("Failed to close String quote in '" +
Report.clippedString(requirementsSubstr.substring(requiredOptClosingQuoteIdx), 20) + "'.");
return null;
}
requiredOptions.add(requirementsSubstr.substring(requiredOptOpenQuoteIdx + 1, requiredOptClosingQuoteIdx));
// Move on to next pair of quotes (if it exists)
requiredOptOpenQuoteIdx = requirementsSubstr.indexOf('"', requiredOptClosingQuoteIdx + 1);
}
// Safety check to make sure that all the required options also actually really exist (as options or rulesets)
for (final String requiredOption : requiredOptions)
{
if (!description.gameOptions().optionExists(requiredOption))
{
boolean foundMatch = false;
for (final Ruleset ruleset : description.rulesets())
{
if (requiredOption.equals(ruleset.heading()))
{
foundMatch = true;
break;
}
}
if (!foundMatch)
{
// throw new RuntimeException("Metadata has option requirement for option or ruleset that does not exist: " + requiredOption);
report.addError("Metadata has option requirement for option or ruleset that does not exist: " + requiredOption);
return null;
}
}
}
// Check if fail any of the requirements for options
boolean failedRequirement = false;
for (final String requiredOpt : requiredOptions)
{
// Each of these requiredOpt strings is quoted, need to remove those when checking condition
if (!active.contains(requiredOpt.replaceAll(Pattern.quote("\""), "")))
{
// Also try ruleset
if
(
activeRuleset < 0
||
!description.rulesets().get(activeRuleset).heading().equals
(
requiredOpt.replaceAll(Pattern.quote("\""), "")
)
)
{
failedRequirement = true;
break;
}
}
}
final StringBuffer stringBuffer = new StringBuffer(str);
if (failedRequirement)
{
// We have to delete this entire block of metadata
stringBuffer.replace(optsCondStartIdx, optsCondClosingBracketIdx + 1, "");
}
else
{
// We satisfy option requirements, so should only cut out the little
// parts used to describe those requirements: (useFor {...} and the closing bracket )
//
// Note: we first cut away stuff at the end, and afterwards stuff in the beginning,
// because if we cut in the beginning first, the later indices would need shifting
stringBuffer.replace(optsCondClosingBracketIdx, optsCondClosingBracketIdx + 1, "");
stringBuffer.replace(optsCondStartIdx, requirementsSubstrIdxEnd + 1, "");
}
str = stringBuffer.toString();
}
return str;
}
//-------------------------------------------------------------------------
/**
* Remove user comments from file (but not from within strings).
*
* @param strIn The string in entry.
* @return The new comment.
*/
public static String removeComments(final String strIn)
{
// TODO: Only remove comments outside strings!
String str = new String(strIn);
int c = 0;
while (c < str.length()-1)
{
if (str.charAt(c) == '"')
{
c = StringRoutines.matchingQuoteAt(str, c) + 1;
if (c <= 0)
{
// Something went wrong: probably not a comment, might be
// an embedded string or ruleset name in quotes
return str;
}
}
else if (str.charAt(c) == '/' && str.charAt(c+1) == '/')
{
// Is a comment
int cc = c + 2;
while (cc < str.length() && str.charAt(cc) != '\n')
cc++;
str = str.substring(0, c) + str.substring(cc); // remove to end of line
}
else
{
c++;
}
}
return str;
}
//-------------------------------------------------------------------------
}
| 50,225 | 27.749857 | 134 |
java
|
Ludii
|
Ludii-master/Language/src/parser/KnownDefines.java
|
package parser;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
import main.FileHandling;
import main.grammar.Define;
import main.grammar.Report;
//-----------------------------------------------------------------------------
/**
* Record of known defines from Common/res/def and below.
*
* @author cambolbro
*/
public class KnownDefines
{
// Map of known defines from bin/def/ and below
private final Map<String, Define> knownDefines = new HashMap<String, Define>();
//-------------------------------------------------------------------------
/**
* Singleton class for known defines.
* @author cambolbro
*/
private static class KnownDefinesProvider
{
public static final KnownDefines KNOWN_DEFINES = new KnownDefines();
}
//-------------------------------------------------------------------------
/**
* Private constructor: access class as singleton through getKnownDefines().
*/
KnownDefines()
{
final Report report = new Report();
loadKnownDefines(report);
if (report.isError())
System.out.println(report);
}
//-------------------------------------------------------------------------
/**
* Access point for getting known defines.
* @return Map of known defines.
*/
public static KnownDefines getKnownDefines()
{
return KnownDefinesProvider.KNOWN_DEFINES;
}
/**
* @return The known defines.
*/
public Map<String, Define> knownDefines()
{
return knownDefines;
}
//-------------------------------------------------------------------------
/**
* Load known defines from file.
*/
void loadKnownDefines(final Report report)
{
knownDefines.clear();
// System.out.println("File.separator is '" + File.separator + "'.");
// Try loading from JAR file
final String[] defs = FileHandling.getResourceListing(KnownDefines.class, "def/", ".def");
if (defs == null)
{
// Not a JAR
try
{
// Start with known .def file
final URL url = KnownDefines.class.getResource("def/rules/play/moves/StepToEmpty.def");
String path = new File(url.toURI()).getPath();
path = path.substring(0, path.length() - "rules/play/moves/StepToEmpty.def".length());
// Get the list of .def files in this directory and subdirectories
try
{
recurseKnownDefines(path, report);
if (report.isError())
return;
}
catch (final Exception e)
{
e.printStackTrace();
}
}
catch (final URISyntaxException exception)
{
exception.printStackTrace();
}
}
else
{
// JAR file
for (final String def : defs)
{
final Define define = processDefFile(def.replaceAll(Pattern.quote("\\"), "/"), "/def/", report);
if (report.isError())
return;
knownDefines.put(define.tag(), define);
}
}
// System.out.println(knownDefines.size() + " known defines loaded:");
// for (final Define define : knownDefines.values())
// System.out.println("+ " + define.tag());
}
void recurseKnownDefines
(
final String path,
final Report report
) throws Exception
{
final File root = new File(path);
final File[] list = root.listFiles();
if (list == null)
return;
for (final File file : list)
{
if (file.isDirectory())
{
// Recurse to subdirectory
recurseKnownDefines(path + file.getName() + File.separator, report);
if (report.isError())
return;
}
else
{
if (!file.getName().contains(".def"))
continue; // not a define file
final String filePath = path + file.getName();
final Define define = processDefFile(filePath.replaceAll(Pattern.quote("\\"), "/"), "/def/", report);
if (report.isError())
return;
knownDefines.put(define.tag(), define);
}
}
}
//-------------------------------------------------------------------------
/**
* Processes a potential define file.
*
* @param defRoot
* @param defFilePath
* @param report
*
* @return The define.
*/
public static Define processDefFile
(
final String defFilePath,
final String defRoot,
final Report report
)
{
final InputStream in = KnownDefines.class.getResourceAsStream(defFilePath.substring(defFilePath.indexOf(defRoot)));
// Extract the definition text from file
final StringBuilder sb = new StringBuilder();
try (final BufferedReader rdr = new BufferedReader(new InputStreamReader(in, "UTF-8")))
{
String line;
while ((line = rdr.readLine()) != null)
sb.append(line + "\n");
}
catch (final IOException e)
{
e.printStackTrace();
}
final Define define = Expander.interpretDefine(sb.toString(), null, report, true);
return define;
}
//-------------------------------------------------------------------------
}
| 5,298 | 24.475962 | 117 |
java
|
Ludii
|
Ludii-master/Language/src/parser/Parser.java
|
package parser;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import compiler.Arg;
import compiler.ArgClass;
import compiler.ArgTerminal;
import compiler.exceptions.CompilerException;
import completer.Completer;
import completer.Completion;
import grammar.Grammar;
import main.Constants;
import main.StringRoutines;
import main.grammar.DefineInstances;
import main.grammar.Description;
import main.grammar.GrammarRule;
import main.grammar.Instance;
import main.grammar.ParseItem;
import main.grammar.Report;
import main.options.UserSelections;
//-----------------------------------------------------------------------------
/**
* Parses .lud game descriptions according to the current Ludii grammar.
*
* @author cambolbro
*/
public class Parser
{
//-------------------------------------------------------------------------
/**
* Private constructor; don't allow class to be constructed.
*/
private Parser()
{
}
//-------------------------------------------------------------------------
/**
* Compile option for testing purposes. Does not interact with UI settings. Not
* for release! Create and throws away GameOptions each time.
*
* @param description
* @param userSelections
* @param report
* @param isVerbose
* @return Executable Game object if can be compiled, else null.
*/
public static boolean parseTest
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean isVerbose
)
{
return expandAndParse(description, userSelections, report, true, isVerbose);
}
//-------------------------------------------------------------------------
/**
* @param description
* @param userSelections
* @param report
* @param isVerbose
* @return Whether the .lud can be parsed.
*/
public static boolean expandAndParse
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean isVerbose
)
{
final boolean allowExamples = false;
return expandAndParse(description, userSelections, report, allowExamples, isVerbose);
}
/**
* @param description
* @param userSelections
* @param report
* @param allowExamples Suppress warnings for ludeme examples, e.g. for LLR.
* @param isVerbose
* @return Whether the .lud can be parsed.
*/
public static boolean expandAndParse
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean allowExamples,
final boolean isVerbose
)
{
if (Completer.needsCompleting(description.rawGameDescription()))
{
String rawGame = description.rawGameDescription();
// System.out.println("Raw game description is: \n" + rawGame);
// Remove formatting so that string matching during completion is more likely to work.
rawGame = Expander.cleanUp(rawGame, report);
// System.out.println("Raw game description after cleaning up is: \n" + rawGame);
//final List<Completion> completions = Completer.completeExhaustive(rawGame, description.maxReconstructions(), report);
final List<Completion> completions = Completer.completeSampled(rawGame, description.maxReconstructions(), report);
System.out.println(completions.size() + " completions found.");
if (!completions.isEmpty())
{
// Replace raw description string passed in with best completion
description.setRaw(completions.get(0).raw());
}
description.setIsRecontruction(true);
}
try
{
try
{
//report.clear();
Expander.expand(description, userSelections, report, isVerbose);
if (report.isError())
{
// System.out.println("Errors while expanding (A):");
// for (final String error : report.errors())
// System.out.println("* " + error);
return false; // failed to expand -- return error
}
if (isVerbose)
{
System.out.println("Define instances:");
for (final DefineInstances defIn : description.defineInstances().values())
System.out.println(defIn + "\n");
}
}
catch (final Exception e)
{
if (report.isError())
{
// System.out.println("Errors while expanding (B):");
// for (final String error : report.errors())
// System.out.println("* " + error);
return false; // failed to expand -- return error
}
//errors.add("Catching exception from Expander..."); //new String(e.getMessage()));
//errors.add("Could not expand game description. Maybe a misplaced bracket pair '(..)' or '{..}'?");
}
return parseExpanded(description, userSelections, report, allowExamples, isVerbose);
}
catch (final CompilerException e)
{
if (isVerbose)
e.printStackTrace();
throw new CompilerException(e.getMessageBody(description.raw()), e);
}
catch (final Exception e)
{
e.printStackTrace();
throw new IllegalArgumentException(e);
}
}
//-------------------------------------------------------------------------
/**
* Public function that calling code should use.
*
* Note: Assumes that Expander has already been called to expand the game description.
*
* @param allowExamples Suppress warnings for ludeme examples, e.g. for LLR.
* @return Whether .lud file parses the current grammar.
*/
private static boolean parseExpanded
(
final Description description,
final UserSelections userSelections,
final Report report,
final boolean allowExamples,
final boolean isVerbose
)
{
//report.clear();
// if (Constants.argCombos == null)
// Constants.createCombos();
//--------------- Check raw game text ----------------
if (description.raw() == null || description.raw().isEmpty())
{
report.addError("Could not expand empty game description. This message was brought to you by Dennis.");
return false;
}
// Extract the raw game description without metadata (assume metadata is after all game description)
String rawGame = description.raw();
//final boolean topLevelRaw = isTopLevelLudeme(rawGame);
if (!allowExamples) // || topLevelRaw)
{
// Check version info
checkVersion(rawGame, report);
}
// Remove comments
rawGame = Expander.removeComments(rawGame);
// Remove metadata
final int mdc = rawGame.indexOf("(metadata");
if (mdc != -1)
rawGame = rawGame.substring(0, mdc).trim();
// Check for matching quotes in raw description
checkQuotes(rawGame, report);
if (report.isError())
return false;
// Check for matching brackets
checkBrackets(rawGame, report);
if (report.isError())
return false;
//--------------- Check expanded text ----------------
if (description.expanded() == null)
{
// Allow more specific tests above to check the problem
report.addError("Could not expand. Check that bracket pairs '(..)' and '{..}' match.");
return false;
}
// Check for matching quotes in expanded description
checkQuotes(description.expanded(), report);
if (report.isError())
return false;
// Check for matching brackets
checkBrackets(description.expanded(), report);
if (report.isError())
return false;
if (!allowExamples)
{
checkOptionsExpanded(description.expanded(), report);
if (report.isError())
return false;
}
//--------------- Check token tree ----------------
// Check token tree was created successfully
if
(
description.tokenForest().tokenTree() == null
||
description.tokenForest().tokenTree().type() == null
)
{
//System.out.println("** Parser.parse(): No token tree.");
report.addLogLine("** Parser.parse(): No token tree.");
report.addError("Couldn't generate token tree from expanded game description.");
return false;
}
if (isVerbose)
{
//System.out.println("+++++++++++++++++++++\nParsing:\n" + description.expanded());
report.addLogLine("+++++++++++++++++++++\nParsing:\n" + description.expanded());
}
//--------------- Check parse tree ----------------
// Create parse tree
description.createParseTree();
if (description.parseTree() == null)
{
report.addError("Couldn't generate parse tree from token tree.");
return false;
}
// Check can match tokens with symbols
matchTokensWithSymbols(description.parseTree(), Grammar.grammar(), report);
if (report.isError())
return false;
final boolean gameOrMatch = isGameOrMatch(description.expanded());
if (!allowExamples || gameOrMatch)
{
checkStrings(description.expanded(), report);
if (report.isError())
return false;
}
//--------------- Check against grammar ----------------
//System.out.println("\n" + parseTree.compare());
//System.out.println("\n" + parseTree.dump(""));
// Check against grammar
description.parseTree().parse(null, report, null);
//description.parseTree().parse(null, report, "");
//System.out.println("\n" + description.parseTree().dump(""));
// Look for deepest failure and report all errors at that level
final int failureDepth = description.parseTree().deepestFailure();
if (failureDepth >= 0)
description.parseTree().reportFailures(report, failureDepth);
return !report.isError();
}
//-------------------------------------------------------------------------
/**
* Finds symbols that match this item's token.
*/
private static void checkQuotes(final String str, final Report report)
{
// Check quotations
final int numQuotes = StringRoutines.numChar(str, '"');
// System.out.println(numQuotes + " quotes.");
if (numQuotes % 2 != 0)
{
report.addError("Mismatched quotation marks '\"'.");
return;
}
}
//-------------------------------------------------------------------------
/**
* Finds symbols that match this item's token.
*/
private static void checkBrackets(final String str, final Report report)
{
// Check brackets
int numOpen = StringRoutines.numChar(str, '(');
int numClose = StringRoutines.numChar(str, ')');
// System.out.println("numOpen=" + numOpen + ", numClose=" + numClose + " '()'.");
if (numOpen < numClose)
{
if (numClose - numOpen == 1)
report.addError("Missing an open bracket '('.");
else
report.addError("Missing " + (numClose - numOpen) + " open brackets '('.");
return;
}
if (numOpen > numClose)
{
if (numOpen - numClose == 1)
report.addError("Missing a close bracket ')'.");
else
report.addError("Missing " + (numOpen - numClose) + " close brackets ')'.");
return;
}
// Check braces
numOpen = StringRoutines.numChar(str, '{');
numClose = StringRoutines.numChar(str, '}');
// System.out.println("numOpen=" + numOpen + ", numClose=" + numClose + " '{}'.");
if (numOpen < numClose)
{
if (numClose - numOpen == 1)
report.addError("Missing an open brace '{'.");
else
report.addError("Missing " + (numClose - numOpen) + " open braces '{'.");
return;
}
if (numOpen > numClose)
{
if (numOpen - numClose == 1)
report.addError("Missing a close brace '}'.");
else
report.addError("Missing " + (numOpen - numClose) + " close braces '}'.");
return;
}
}
//-------------------------------------------------------------------------
/**
* Check that all options have been expanded.
*/
private static void checkOptionsExpanded(final String expanded, final Report report)
{
int c = -1; // start at char 0 (c+1)
while (true)
{
c = expanded.indexOf("<", c+1);
if (c == -1)
break;
int cc = StringRoutines.matchingBracketAt(expanded, c);
if (cc == -1)
cc = c + 5;
final char ch = expanded.charAt(c+1);
if (StringRoutines.isNameChar(ch))
{
report.addError("Option tag " + (expanded.substring(c, cc+1)) + " not expanded.");
return;
}
}
}
//-------------------------------------------------------------------------
/**
* Finds symbols that match this item's token.
*/
private static void matchTokensWithSymbols
(
final ParseItem item,
final Grammar grammar,
final Report report
)
{
if (item.token() == null)
{
//System.out.println("Null token for item: " + item.dump(" "));
report.addError("Null token for item: " + item.dump(" "));
return;
}
try
{
// item.matchSymbols(grammar, report);
matchSymbols(item, grammar, report);
}
catch (final Exception e)
{
//errors.add("Catching exception...");
//System.out.println("- Catching matchSymbols() exception...");
}
if (item.instances().isEmpty())
{
switch (item.token().type())
{
case Terminal:
String error = "Couldn't find token '" + item.token().name() + "'.";
if (Character.isLowerCase(item.token().name().charAt(0)))
error += " Maybe missing bracket '(" + item.token().name() + " ...)'?";
report.addError(error);
break;
case Class:
report.addError("Couldn't find ludeme class for token '" + item.token().name() + "'.");
break;
case Array:
// Not an error
break;
}
}
for (final ParseItem arg : item.arguments())
matchTokensWithSymbols(arg, grammar, report);
}
/**
* @param item
* @param grammar
* @param report
*/
public static void matchSymbols(final ParseItem item, final Grammar grammar, final Report report)
{
item.clearInstances();
Arg arg;
switch (item.token().type())
{
case Terminal: // String, number, enum, True, False
arg = new ArgTerminal(item.token().name(), item.token().parameterLabel());
arg.matchSymbols(grammar, report); // instantiates actual object(s), not need for clauses
final String str = arg.symbolName();
if (!str.isEmpty() && Character.isLowerCase(str.charAt(0)))
{
final String msg = "Terminal constant '" + str + "' is lowercase.";
report.addWarning(msg);
System.out.println(msg); // to remind us to tidy up the game descriptions
}
for (final Instance instance : arg.instances())
item.add(instance);
break;
case Class:
// Find matching symbols and their clauses
arg = new ArgClass(item.token().name(), item.token().parameterLabel());
arg.matchSymbols(grammar, report);
for (final Instance instance : arg.instances())
item.add(instance);
// Associate clauses with each instance of arg
for (final Instance instance : item.instances())
{
final GrammarRule rule = instance.symbol().rule();
if (rule != null)
instance.setClauses(rule.rhs());
}
break;
case Array:
// Do nothing: use instances of each element on a case-by-case basis
break;
}
}
//-------------------------------------------------------------------------
private static void checkStrings(final String expanded, final Report report)
{
// Get number of players?
int numPlayers = 0;
final int playersFrom = expanded.indexOf("(players");
if (playersFrom >= 0)
{
final int playersTo = StringRoutines.matchingBracketAt(expanded, playersFrom);
if (playersTo >= 0)
{
// Check if defined in form (players { (player ...) (player ...) })
int p = 0;
while (true)
{
p = expanded.indexOf("(player", p+1);
if (p == -1)
break;
// Check that "(player":
// 1. is within scope of (players ...) as more than one Player class
// 2. but doesn't match "(players"
if (p > playersFrom && p < playersTo && expanded.charAt(p + 7) != 's')
numPlayers++;
}
if (numPlayers == 0)
{
// Check if defined in form (players N)
p = expanded.indexOf("(players");
if (p != -1)
{
final int pp = StringRoutines.matchingBracketAt(expanded, p);
if (pp == -1)
{
report.addError("No closing bracket for '(players ...'.");
return;
}
final String playerString = expanded.substring(p, pp+1).trim();
final String countString = expanded.substring(p+8, pp).trim();
final String[] subs = countString.split(" ");
// System.out.println("countString is '" + countString + "', subs[0] is '" + subs[0] + "'.");
try
{
numPlayers = Integer.parseInt(subs[0]);
}
catch (final Exception e)
{
// System.out.println(numPlayers + " players.");
report.addError("Couldn't extract player count from '" + playerString + "'.");
return;
}
}
}
}
}
//System.out.println(numPlayers + " players.");
// Get list of known strings: player names, named items, phases, coordinates, etc.
final Map<Integer, String> knownStrings = new HashMap<Integer, String>();
// Add known defaults
final String[] defaults =
{ "Player", "Board", "Hand", "Ball", "Bag", "Domino" };
for (final String def : defaults)
knownStrings.put(Integer.valueOf(def.hashCode()), def);
extractKnownStrings(expanded, "(game", true, knownStrings, report);
extractKnownStrings(expanded, "(match", true, knownStrings, report);
extractKnownStrings(expanded, "(subgame", true, knownStrings, report);
extractKnownStrings(expanded, "(subgame", false, knownStrings, report);
extractKnownStrings(expanded, "(players", false, knownStrings, report);
extractKnownStrings(expanded, "(equipment", false, knownStrings, report);
extractKnownStrings(expanded, "(phase", true, knownStrings, report);
extractKnownStrings(expanded, "(vote", true, knownStrings, report);
extractKnownStrings(expanded, "(move Vote", true, knownStrings, report);
extractKnownStrings(expanded, "(is Proposed", true, knownStrings, report);
extractKnownStrings(expanded, "(is Decided", true, knownStrings, report);
extractKnownStrings(expanded, "(note", true, knownStrings, report);
extractKnownStrings(expanded, "(trigger", true, knownStrings, report);
extractKnownStrings(expanded, "(is Trigger", true, knownStrings, report);
extractKnownStrings(expanded, "(trackSite", false, knownStrings, report);
extractKnownStrings(expanded, "(set Var", false, knownStrings, report);
extractKnownStrings(expanded, "(var", false, knownStrings, report);
extractKnownStrings(expanded, "(remember", false, knownStrings, report);
extractKnownStrings(expanded, "(set RememberValue", false, knownStrings, report);
extractKnownStrings(expanded, "(values Remembered", false, knownStrings, report);
// System.out.println("Known strings:");
// for (final String known : knownStrings.values())
// System.out.println("> " + known);
// Check rest of description for strings
//int c = ee; // start at end of (equipment ...)
int c = -1;
while (true)
{
c = expanded.indexOf('"', c+1);
if (c == -1)
break; // no more strings in description
final int cc = StringRoutines.matchingQuoteAt(expanded, c);
if (cc == -1)
{
report.addError("Couldn't close string: " + expanded.substring(c));
return;
}
final String str = expanded.substring(c+1, cc);
// System.out.println("Checking clause: " + str);
if (!StringRoutines.isCoordinate(str)) //str.length() > 2) // ignore trivial coordinates
{
// Check whether this string is known
boolean match = false;
final int key = str.hashCode();
if (knownStrings.containsKey(Integer.valueOf(key)))
match = true;
if (!match)
{
// Compare each individual string
//for (final String item : knownStrings)
for (final String known : knownStrings.values())
{
if (known.equals(str))
{
match = true;
break;
}
// System.out.println("str=" + str + ", known=" + known);
if (!known.contains(str) && !str.contains(known))
continue; // not a possible match
if (Math.abs(str.length() - known.length()) > 2)
continue; // not a numbered variant
// Check player index is in player range
// final int pid = StringRoutines.numberAtEnd(str);
//System.out.println("pid=" + pid + ", numPlayers=" + numPlayers);
// if (pid < 0 || pid > numPlayers + 1)
// {
// errors.add("Bad player index " + pid + " on item '" + str + "'.");
// return;
// }
// if (pid > numPlayers && !str.contains("Hand"))
// report.addWarning("Item '" + str + "' is numbered " + pid + " but only " + numPlayers + " players.");
match = true;
break;
}
}
if (!match && str.length() <= 5 && StringRoutines.isCoordinate(str))
continue; // allow any coordinate to match
if (!match)
{
report.addError("Could not match string '" + str + "'. Misspelt define or item?");
return;
}
}
c = cc + 1;
}
}
/**
* Extracts strings from within the specified clause(s).
* Set 'firstStringPerClause' to false if only want to pick up first String, e.g. game or phase name.
*/
private static void extractKnownStrings
(
final String expanded,
final String targetClause,
final boolean firstStringPerClause,
final Map<Integer, String> knownStrings,
final Report report
)
{
int e = -1;
while (true)
{
// Find next instance of target clause
e = expanded.indexOf(targetClause, e+1);
if (e == -1)
return;
// System.out.println("Found clause starting " + targetClause + "...");
// Extract clause
final int ee = StringRoutines.matchingBracketAt(expanded, e);
if (ee == -1)
{
report.addError("Couldn't close string: " + expanded.substring(e));
return;
}
final String clause = expanded.substring(e, ee+1);
// System.out.println("Clause is: " + expanded.substring(e));
// Get substrings within clause
int i = -1;
while (true)
{
i = clause.indexOf('"', i+1);
if (i == -1)
break; // no more substrings in clause
// System.out.println("substring from: " + clause.substring(i));
final int ii = StringRoutines.matchingQuoteAt(clause, i);
if (ii == -1)
{
report.addError("Couldn't close item string: " + clause.substring(i));
return;
}
final String known = clause.substring(i+1, ii);
// System.out.println("known: " + known);
if (!StringRoutines.isCoordinate(known))
{
// Ignore coordinates (e.g. "A1", "A123", "AA123", "123")
// System.out.println("Putting: " + known);
knownStrings.put(Integer.valueOf(known.hashCode()), known);
if (firstStringPerClause)
break; // exit this clause, but still check for subsequent clauses
}
i = ii; // + 1;
}
}
}
//-------------------------------------------------------------------------
private static void checkVersion(final String raw, final Report report)
{
final int v = raw.indexOf("(version");
if (v == -1)
{
// System.out.println("** No version info.");
report.addWarning("No version info.");
return; // no version info
}
int s = v;
while (s < raw.length() && raw.charAt(s) != '"')
s++;
if (s >= raw.length())
{
//System.out.println("** Parser.checkVersion(): Couldn't find version string.");
report.addError("Couldn't find version string in (version ...) entry.");
return;
}
final int ss = StringRoutines.matchingQuoteAt(raw, s);
if (ss == -1)
{
report.addError("Couldn't close version string in (version ...) entry.");
return;
}
final String version = raw.substring(s+1, ss);
// Integer value representing the version number of the game description.
final int gameVersionInteger = Integer.valueOf(version.split("\\.")[0]).intValue() * 1000000
+ Integer.valueOf(version.split("\\.")[1]).intValue() * 1000
+ Integer.valueOf(version.split("\\.")[2]).intValue();
// Integer value representing the version number of the app.
final int appVersionInteger = Integer.valueOf(Constants.LUDEME_VERSION.split("\\.")[0]).intValue() * 1000000
+ Integer.valueOf(Constants.LUDEME_VERSION.split("\\.")[1]).intValue() * 1000
+ Integer.valueOf(Constants.LUDEME_VERSION.split("\\.")[2]).intValue();
final int result = appVersionInteger - gameVersionInteger;
if (result < 0)
report.addWarning("Game version (" + version + ") newer than app version (" + Constants.LUDEME_VERSION + ").");
else if (result > 0)
report.addWarning("Game version (" + version + ") older than app version (" + Constants.LUDEME_VERSION + ").");
}
//-------------------------------------------------------------------------
/**
* @param cls
* @return Formatted tooltip help string for the specified class. For use in the
* ludeme editors.
*/
public static String tooltipHelp(final Class<?> cls)
{
if (cls.getSimpleName().equalsIgnoreCase("add"))
{
return
"add\n" +
"Add a piece...\n" +
"\n" +
"Format\n" +
"(add ...)\n" +
"where:\n" +
"• <int>: Minimum length of lines.\n" +
"• [<absoluteDirection>]: Direction category that potential lines must belong to.\n" +
"\n" +
"Example\n" +
"(add ...)\n";
}
return "No tooltip found for class " + cls.getName();
}
//-------------------------------------------------------------------------
/**
* @param cls
* @return List of ludemes (or terminal objects) that could be used as
* alternatives for the specified class. For use in the ludeme editors.
*/
public static List<Class<?>> alternativeClasses(final Class<?> cls)
{
final List<Class<?>> alternatives = new ArrayList<Class<?>>();
if (cls.getSimpleName().equalsIgnoreCase("and"))
{
// A sampling of some ludemes that can be used instead of Line
Class<?> alternative = null;
try { alternative = Class.forName("game.functions.booleans.math.And"); }
catch (final ClassNotFoundException e) { e.printStackTrace(); }
alternatives.add(alternative);
}
return alternatives;
}
/**
* @param cls
* @return List of ludemes (or terminal objects) that could be used as
* alternatives for the specified class. For use in the ludeme editors.
*/
public static List<Object> alternativeInstances(final Class<?> cls)
{
final List<Object> alternatives = new ArrayList<Object>();
// if (cls.getSimpleName().equalsIgnoreCase("and"))
// {
// // A sampling of some ludemes that can be used instead of Line
// alternatives.add(new And(null, null));
// }
// TODO: Implement alternative ludemes list.
System.out.println("* Note: Alternative ludemes list not implemented yet.");
return alternatives;
}
//-------------------------------------------------------------------------
/**
* @param description Game description (may be expanded or not).
* @param cursorAt Character position of cursor.
* @param isSelect True if selected.
* @param type Type of selection.
* @return Range of scope of current token.
*/
public static TokenRange tokenScope
(
final String description, final int cursorAt, final boolean isSelect,
final SelectionType type
)
{
System.out.println("Selection type: " + type);
if (cursorAt <= 0 || cursorAt >= description.length())
{
System.out.println("** Grammar.classPaths(): Invalid cursor position " + cursorAt + " specified.");
return null;
}
// Get full keyword at cursor
int c = cursorAt - 1;
char ch = description.charAt(c);
if (!StringRoutines.isTokenChar(ch))
{
// Not currently on a token (or at the start of one): return nothing
return null;
}
while (c > 0 && StringRoutines.isTokenChar(ch))
{
c--;
ch = description.charAt(c);
if (ch == '<' && StringRoutines.isLetter(description.charAt(c + 1)))
break; // should be a rule
}
// Get token
int cc = cursorAt;
char ch2 = description.charAt(cc);
while (cc < description.length() && StringRoutines.isTokenChar(ch2))
{
cc++;
if (cc < description.length())
ch2 = description.charAt(cc);
}
if (cc >= description.length())
{
System.out.println("** Grammar.classPaths(): Couldn't find end of token scope from position " + cursorAt + ".");
return null;
}
// if (ch2 == ':')
// {
// // Token is a parameter name: return nothing
// return null;
// }
final String token = description.substring(c+1, cc);
System.out.println("token: " + token);
if (isSelect)
{
// Select entire entry
// System.out.println("isSelect substring is: " + description.substring(c, cc));
if (description.charAt(c) == ':' || description.charAt(c - 1) == ':')
{
// Is named parameter (second test is to catch "name:<rule>")
c -= 2;
while (c > 0 && StringRoutines.isTokenChar(description.charAt(c)))
c--;
c++;
// System.out.println("....new substring ':' is: " + description.substring(c, cc));
}
if (description.charAt(cc) == ':' || description.charAt(cc + 1) == ':')
{
// Is named parameter (clicked on name, not value)
cc++;
while (cc < description.length() && StringRoutines.isTokenChar(description.charAt(cc)))
cc++;
// System.out.println("....new substring 'name:' is: " + description.substring(c, cc));
}
if (c > 0 && description.charAt(c - 1) == '[')
{
// Is an optional parameter
c--;
cc = StringRoutines.matchingBracketAt(description, c) + 1;
// System.out.println("....new substring '[' A is: " + description.substring(c, cc));
}
else if (c > 0 && description.charAt(c) == '[')
{
// Is an optional parameter
cc = StringRoutines.matchingBracketAt(description, c) + 1;
// System.out.println("....new substring '[' B is: " + description.substring(c, cc));
}
else if (description.charAt(cc + 1) == ']')
{
cc++;
c = cc - 1;
while (c > 0 && description.charAt(c) != '[')
c--;
// System.out.println("....new substring ']' is: " + description.substring(c, cc));
}
}
// Handle primitive and predefined types
if (token.charAt(0) == '"')
{
// Is a string: note that quotes '"' are a valid token character
System.out.println("String scope includes: " + description.substring(c, cc));
return new TokenRange(c, cc);
}
if (token.equalsIgnoreCase("true"))
{
if (description.charAt(c) == ':')
c++; // named parameter
System.out.println("True scope includes: " + description.substring(c, cc));
return new TokenRange(c, cc);
}
if (token.equalsIgnoreCase("false"))
{
if (description.charAt(c) == ':')
c++; // named parameter
System.out.println("False scope includes: " + description.substring(c, cc));
return new TokenRange(c, cc);
}
if (StringRoutines.isInteger(token))
{
System.out.println("Int scope includes: " + description.substring(c, cc));
return new TokenRange(c, cc);
}
if (StringRoutines.isFloat(token) || StringRoutines.isDouble(token))
{
System.out.println("Float scope includes: " + description.substring(c, cc));
return new TokenRange(c, cc);
}
if (type == SelectionType.SELECTION || type == SelectionType.TYPING)
{
// Return scope of token, not entire ludeme
if (ch == '(')
c++;
System.out.println("Selected token scope includes: '" + description.substring(c, cc) +"'");
return new TokenRange(c, cc);
}
// Filter out unwanted matches
if (ch == '(')
{
// Is a class constructor: match to end of scope
// System.out.println("Is a constructor '" + partialKeyword + "'...");
final int closing = StringRoutines.matchingBracketAt(description, c);
if (closing < 0)
{
System.out.println("** Couldn't close token: " + token);
return null;
}
System.out.println("Class scope includes: " + description.substring(c, closing+1));
return new TokenRange(c, closing+1);
}
if (ch == '<')
{
// Is a rule
System.out.println("Rule scope includes: " + description.substring(c, cc));
return new TokenRange(c, cc);
}
if (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == ':' || ch == '{')
{
// Is a terminal (probably an enum)
System.out.println("Enum constant scope includes: '" + description.substring(c+1, cc) +"'");
return new TokenRange(c+1, cc);
}
//return null;
return new TokenRange(c, cc);
}
//-------------------------------------------------------------------------
// /**
// * @return Whether string describes a top-level ludeme (Game, Match or Metadata).
// */
// public static boolean isTopLevelLudeme(final String str)
// {
// return str.contains("(game") || str.contains("(match") || str.contains("(metadata");
// }
/**
* @param str Game description.
* @return Whether string describes a Game or Match.
*/
public static boolean isGameOrMatch(final String str)
{
return str.contains("(game") || str.contains("(match");
}
//-------------------------------------------------------------------------
}
| 33,029 | 28.464764 | 122 |
java
|
Ludii
|
Ludii-master/Language/src/parser/SelectionType.java
|
package parser;
/**
* Types of ways in which editor text can be replaced.
*
* @author cambolbro
*/
public enum SelectionType
{
/** Replacement through right-click context selection. */
CONTEXT,
/** Replacement of selected text. */
SELECTION,
/** Replacement through autosuggest in response to typing. */
TYPING
}
| 329 | 16.368421 | 62 |
java
|
Ludii
|
Ludii-master/Language/src/parser/TokenRange.java
|
package parser;
/**
* Specifies a token's range within a String.
* @author cambolbro
*/
public class TokenRange
{
final int from;
final int to;
//-------------------------------------------------------------------------
/**
* @param from Range from (inclusive).
* @param to Range to (exclusive).
*/
public TokenRange(final int from, final int to)
{
this.from = from;
this.to = to;
}
//-------------------------------------------------------------------------
/**
* @return Range from (inclusive).
*/
public int from()
{
return from;
}
/**
* @return Range to (exclusive).
*/
public int to()
{
return to;
}
//-------------------------------------------------------------------------
}
| 743 | 15.533333 | 76 |
java
|
Ludii
|
Ludii-master/LudiiDocGen/src/help/GenerateLudiiEditorHelpFile.java
|
package help;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Modifier;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import annotations.Hide;
import gnu.trove.list.array.TIntArrayList;
import grammar.ClassEnumerator;
import grammar.Grammar;
import main.Constants;
import main.StringRoutines;
import main.grammar.Symbol;
import metadata.MetadataItem;
import other.Ludeme;
/**
* Code to generate a help file for generating auto-complete etc. in Ludii's editor.
*
* @author Dennis Soemers
*/
public class GenerateLudiiEditorHelpFile
{
private static final Grammar grammar = Grammar.grammar();
private static final String HELP_FILE_NAME = "../Common/res/help/EditorHelp.txt";
private static final String DEFS_DIR = "../Common/res/def";
/** Map of pieces of text to replace in documentation */
private static final Map<String, String> TEXT_TO_REPLACE = new HashMap<String, String>();
/** All the game classes (under the game package) */
private static List<Class<?>> gameClasses;
/** All the metadata classes (under the metadata package) */
private static List<Class<?>> metadataClasses;
static
{
TEXT_TO_REPLACE.put("MAX_DISTANCE", "" + Constants.MAX_DISTANCE);
TEXT_TO_REPLACE.put("\\\\url", "\\url");
TEXT_TO_REPLACE.put("\\\\texttt{", "\\texttt{");
TEXT_TO_REPLACE.put("$\\\\leq$", "<=");
TEXT_TO_REPLACE.put("$\\\\geq$", ">=");
TEXT_TO_REPLACE.put("$\\\\neq$", "$=/=");
TEXT_TO_REPLACE.put("\\\\frac{", "\\frac{");
TEXT_TO_REPLACE.put("\\\\exp(", "\\exp(");
TEXT_TO_REPLACE.put("\\\\tanh", "\\tanh");
try
{
gameClasses = ClassEnumerator.getClassesForPackage(Class.forName("game.Game").getPackage());
metadataClasses = ClassEnumerator.getClassesForPackage(Class.forName("metadata.Metadata").getPackage());
}
catch (final ClassNotFoundException e)
{
e.printStackTrace();
}
}
/**
* Main method
* @throws ParserConfigurationException
* @throws SAXException
* @throws IOException
* @throws ClassNotFoundException
*/
public static void generateHelp() throws ParserConfigurationException, SAXException, IOException, ClassNotFoundException
{
// First we'll read the XML file we generated
final File inputFile = new File("../LudiiDocGen/out/xml/jel.xml");
final DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
final DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
final Document doc = dBuilder.parse(inputFile);
final Element root = doc.getDocumentElement();
final List<ClassTreeNode> rootPackages = new ArrayList<ClassTreeNode>();
final List<Node> classNodes = xmlChildrenForName(root, "jelclass");
for (int i = 0; i < classNodes.size(); ++i)
{
final Node child = classNodes.get(i);
if (hasAnnotation(child, "Hide") || hasAnnotation(child, "ImpliedRule"))
continue;
final NamedNodeMap attributes = child.getAttributes();
final String packageStr = attributes.getNamedItem("package").getTextContent();
String type = attributes.getNamedItem("type").getTextContent();
final String fullType = packageStr + "." + type.replaceAll(Pattern.quote("."), Matcher.quoteReplacement("$"));
final Class<?> clazz = Class.forName(fullType);
if (!Ludeme.class.isAssignableFrom(clazz) && !MetadataItem.class.isAssignableFrom(clazz) && !clazz.isEnum())
continue; // We skip classes that are neither Ludemes nor enums
// if ((clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) && !clazz.isEnum())
// continue; // We skip interfaces and abstract classes
if (type.contains("."))
{
if (!clazz.isEnum())
{
System.out.println("Skipping inner class type: " + fullType);
continue;
}
else
{
// Need to get rid of outer class
final String[] typeSplit = type.split(Pattern.quote("."));
type = typeSplit[typeSplit.length - 1];
}
}
boolean grammarSymbolUsed = false;
boolean metadataSymbolUsed = false;
final List<Symbol> grammarSymbols = grammar.symbolListFromClassName(type);
if (grammarSymbols != null)
{
for (final Symbol symbol : grammarSymbols)
{
if (symbol.usedInDescription())
grammarSymbolUsed = true;
if (symbol.usedInGrammar())
grammarSymbolUsed = true;
if (symbol.usedInMetadata())
metadataSymbolUsed = true;
if (grammarSymbolUsed && metadataSymbolUsed)
break;
}
}
if (!grammarSymbolUsed && !metadataSymbolUsed && !MetadataItem.class.isAssignableFrom(clazz))
{
System.out.println("Ignoring type not used in grammar or metadata: " + fullType);
continue;
}
final String[] subpackages = packageStr.split(Pattern.quote("."));
// Find matching package in our list of root packages
ClassTreeNode currentNode = null;
List<ClassTreeNode> currentPackages = rootPackages;
final List<String> fullTypeStrParts = new ArrayList<String>();
for (int j = 0; j < subpackages.length; ++j)
{
boolean foundPackage = false;
fullTypeStrParts.add(subpackages[j]);
for (final ClassTreeNode pckg : currentPackages)
{
if (subpackages[j].equals(pckg.name))
{
currentNode = pckg;
foundPackage = true;
break;
}
}
if (!foundPackage)
{
// Didn't find a match, so have to instantiate a new root package
currentNode = new ClassTreeNode(subpackages[j], true, StringRoutines.join(".", fullTypeStrParts), clazz.isEnum(), child);
currentPackages.add(currentNode);
}
currentPackages = currentNode.children;
}
// Create new node for this type
fullTypeStrParts.add(type);
currentPackages.add(new ClassTreeNode(type, false, attributes.getNamedItem("fulltype").getTextContent(), clazz.isEnum(), child));
}
// Try to nicely sort all packages; first classes in alphabetical order, then subpackages
sortPackages(rootPackages);
// Create StringBuilder to contain all our help info
final StringBuilder sb = new StringBuilder();
// Process all our packages in a depth-first manner
for (final ClassTreeNode node : rootPackages)
{
process(node, sb);
}
// Also process all our def files
processDefFiles(sb);
// Postprocess our full string to fix type names,
// and replace other keywords that need replacing
while (true)
{
final int paramStartIdx = sb.indexOf("<PARAM:");
if (paramStartIdx < 0) // we're done
break;
final int paramEndIdx = sb.indexOf(">", paramStartIdx);
String paramTypeStr = sb.substring(paramStartIdx, paramEndIdx);
paramTypeStr = paramTypeStr.substring("<PARAM:".length(), paramTypeStr.length());
if (paramTypeStr.endsWith("[]"))
paramTypeStr = paramTypeStr.substring(0, paramTypeStr.length() - "[]".length());
final String[] paramTypeStrSplit = paramTypeStr.split(Pattern.quote("."));
final String paramTypeText = typeString(StringRoutines.lowerCaseInitial(paramTypeStrSplit[paramTypeStrSplit.length - 1]));
sb.replace(paramStartIdx, paramEndIdx + 1, paramTypeText);
}
// Remove \texttt{} LaTeX commands
while (true)
{
final int textttStartIdx = sb.indexOf("\\texttt{");
if (textttStartIdx < 0) // we're done
break;
final int textttEndIdx = sb.indexOf("}", textttStartIdx);
sb.replace
(
textttStartIdx,
textttEndIdx + 1,
sb.substring(textttStartIdx + "\\texttt{".length(), textttEndIdx)
);
}
for (final String key : TEXT_TO_REPLACE.keySet())
{
while (true)
{
final int startIdx = sb.indexOf(key);
if (startIdx < 0) // we're done
break;
final int endIdx = startIdx + key.length();
sb.replace(startIdx, endIdx, TEXT_TO_REPLACE.get(key));
}
}
// Write our help file
final File outFile = new File(HELP_FILE_NAME);
outFile.getParentFile().mkdirs();
System.out.println("Writing file: " + outFile.getCanonicalPath());
try (final PrintWriter writer = new PrintWriter(outFile))
{
writer.write(sb.toString());
}
}
/**
* Processes the given node
* @param node
* @param sb
* @throws ClassNotFoundException
*/
private static void process(final ClassTreeNode node, final StringBuilder sb) throws ClassNotFoundException
{
if (node.isPackage)
{
for (final ClassTreeNode child : node.children)
{
process(child, sb);
}
}
else
{
if (node.isEnum)
processEnumNode(node, sb);
else
processClassNode(node, sb);
}
}
/**
* Processes the given class node
* @param node
* @param sb
* @throws ClassNotFoundException
*/
private static void processClassNode(final ClassTreeNode node, final StringBuilder sb) throws ClassNotFoundException
{
// We're starting a new class
final Class<?> clazz = Class.forName(node.fullType);
final String ludemeName = StringRoutines.lowerCaseInitial(node.name);
appendLine(sb, "TYPE: " + node.fullType);
// Handle @Alias annotation
String unformattedAlias = null;
if (hasAnnotation(node.xmlNode, "Alias"))
{
final Node annotationsNode = xmlChildForName(node.xmlNode, "annotations");
if (annotationsNode != null)
{
final List<Node> annotationNodes = xmlChildrenForName(annotationsNode, "annotation");
for (final Node annotationNode : annotationNodes)
{
final String annotationType = annotationNode.getAttributes().getNamedItem("type").getTextContent();
if (annotationType.equals("Alias"))
{
final Node valuesNode = xmlChildForName(annotationNode, "values");
final Node valueNode = xmlChildForName(valuesNode, "value");
unformattedAlias = valueNode.getAttributes().getNamedItem("value").getTextContent();
break;
}
}
}
}
// Write the comments on top of class
final Node classCommentNode = xmlChildForName(node.xmlNode, "comment");
if (classCommentNode != null)
{
final Node descriptionNode = xmlChildForName(classCommentNode, "description");
if (descriptionNode != null)
appendLine(sb, "TYPE JAVADOC: " + descriptionNode.getTextContent().replaceAll(Pattern.quote("\n"), " ").trim());
}
if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers()))
{
// Interface or abstract class
final List<Class<?>> potentialSubclasses;
if (node.fullType.startsWith("game"))
{
potentialSubclasses = gameClasses;
}
else if (node.fullType.startsWith("metadata"))
{
potentialSubclasses = metadataClasses;
}
else
{
potentialSubclasses = null;
System.err.println("Interface / abstract class starts with neither game nor metadata!");
}
final List<String> subclassTypes = new ArrayList<String>();
for (final Class<?> cls : potentialSubclasses)
{
if (clazz.isAssignableFrom(cls))
{
if (cls.isAssignableFrom(clazz))
continue; // Same class, skip this
if (cls.isAnnotationPresent(Hide.class))
continue; // Skip hidden classes
subclassTypes.add(cls.getName());
}
}
for (final String subclassType : subclassTypes)
{
appendLine(sb, "SUBCLASS: " + subclassType);
}
}
else
{
// Just a normal class
final Node methodsNode = xmlChildForName(node.xmlNode, "methods");
final List<Node> constructors = xmlChildrenForName(methodsNode, "constructor");
// also add public static create() methods to the constructors
final List<Node> createMethods = xmlChildrenForName(methodsNode, "method");
for (final Node methodNode : createMethods)
{
final Node staticAttribute = methodNode.getAttributes().getNamedItem("static");
if
(
staticAttribute != null &&
staticAttribute.getTextContent().equals("true") &&
methodNode.getAttributes().getNamedItem("visibility").getTextContent().equals("public") &&
methodNode.getAttributes().getNamedItem("name").getTextContent().equals("construct")
)
{
constructors.add(methodNode);
}
}
// Remove constructors with @Hide annotations
constructors.removeIf((final Node ctor) -> { return hasAnnotation(ctor, "Hide"); });
for (int ctorIdx = 0; ctorIdx < constructors.size(); ++ctorIdx)
{
final Node ctor = constructors.get(ctorIdx);
if (ctor.getAttributes().getNamedItem("visibility").getTextContent().equals("public"))
{
// A public constructor
appendLine(sb, "NEW CTOR");
final StringBuilder ctorSb = new StringBuilder();
if (unformattedAlias != null)
ctorSb.append("(" + unformattedAlias + "");
else
ctorSb.append("(" + ludemeName + "");
final Node paramsNode = xmlChildForName(ctor, "params");
final List<String> paramSymbols = new ArrayList<String>();
final TIntArrayList singleValueEnumParamIndices = new TIntArrayList();
if (paramsNode != null)
{
final List<Node> paramNodes = xmlChildrenForName(paramsNode, "param");
boolean orSequence = false;
boolean or2Sequence = false;
for (int paramNodeIdx = 0; paramNodeIdx < paramNodes.size(); ++paramNodeIdx)
{
final Node paramNode = paramNodes.get(paramNodeIdx);
// Figure out how to write this param
final String paramName = paramNode.getAttributes().getNamedItem("name").getTextContent();
String paramFullType = paramNode.getAttributes().getNamedItem("fulltype").getTextContent();
boolean named = false;
boolean optional = false;
int numArrayDims = 0;
boolean startNewOrSequence = false;
boolean endPreviousOrSequence = (orSequence || or2Sequence);
while (paramFullType.endsWith("[]"))
{
paramFullType = paramFullType.substring(0, paramFullType.length() - "[]".length());
numArrayDims += 1;
}
final Node annotationsNode = xmlChildForName(paramNode, "annotations");
if (annotationsNode != null)
{
final List<Node> annotationNodes = xmlChildrenForName(annotationsNode, "annotation");
for (final Node annotationNode : annotationNodes)
{
final String annotationType = annotationNode.getAttributes().getNamedItem("type").getTextContent();
if (annotationType.equals("Name"))
{
named = true;
}
else if (annotationType.equals("Opt"))
{
optional = true;
}
else if (annotationType.equals("Or"))
{
if (orSequence)
endPreviousOrSequence = false;
else
startNewOrSequence = true;
orSequence = true;
or2Sequence = false;
}
else if (annotationType.equals("Or2"))
{
if (or2Sequence)
endPreviousOrSequence = false;
else
startNewOrSequence = true;
orSequence = false;
or2Sequence = true;
}
}
}
if (endPreviousOrSequence)
{
orSequence = false;
or2Sequence = false;
ctorSb.append(")");
}
// Write this param
ctorSb.append(" ");
if (startNewOrSequence)
ctorSb.append("(");
else if (orSequence || or2Sequence)
ctorSb.append(" | ");
final StringBuilder paramSymbolSb = new StringBuilder();
if (optional)
paramSymbolSb.append("[");
if (named)
paramSymbolSb.append(paramName + ":");
for (int i = 0; i < numArrayDims; ++i)
{
paramSymbolSb.append("{");
}
final Class<?> paramClass = Class.forName(paramFullType);
if (Enum.class.isAssignableFrom(paramClass))
{
if (paramClass.getEnumConstants().length == 1)
{
paramSymbolSb.append(paramClass.getEnumConstants()[0].toString());
singleValueEnumParamIndices.add(paramNodeIdx);
}
else
{
paramSymbolSb.append("<PARAM:" + paramFullType + ">");
}
}
else
{
paramSymbolSb.append("<PARAM:" + paramFullType + ">");
}
for (int i = 0; i < numArrayDims; ++i)
{
paramSymbolSb.append("}");
}
if (optional)
paramSymbolSb.append("]");
paramSymbols.add(paramSymbolSb.toString());
ctorSb.append(paramSymbolSb);
}
if (orSequence || or2Sequence) // close final or sequence
ctorSb.append(")");
}
ctorSb.append(")");
appendLine(sb, ctorSb.toString());
if (paramSymbols.size() > 0)
{
// Add explanations of all the params
final List<Node> paramNodes = xmlChildrenForName(paramsNode, "param");
for (int paramNodeIdx = 0; paramNodeIdx < paramNodes.size(); ++paramNodeIdx)
{
if (singleValueEnumParamIndices.contains(paramNodeIdx))
continue; // Skip this param, it's a single-value enum
final Node paramNode = paramNodes.get(paramNodeIdx);
final Node commentNode = paramNode.getAttributes().getNamedItem("comment");
if (commentNode == null)
System.err.println("WARNING: No Javadoc comment for " + (paramNodeIdx + 1) + "th param of " + (ctorIdx + 1) + "th constructor of " + node.fullType);
String paramDescription = commentNode != null ? commentNode.getTextContent() : "";
paramDescription = StringRoutines.cleanWhitespace(paramDescription);
appendLine(sb, "PARAM JAVADOC: " + paramSymbols.get(paramNodeIdx) + ": " + paramDescription);
}
}
final Node ctorCommentNode = xmlChildForName(ctor, "comment");
if (ctorCommentNode != null)
{
final List<Node> attributes = xmlChildrenForName(ctorCommentNode, "attribute");
// Collect constructor-specific examples
boolean foundExample = false;
for (final Node attribute : attributes)
{
if (attribute.getAttributes().getNamedItem("name").getTextContent().equals("@example"))
{
final Node descriptionNode = xmlChildForName(attribute, "description");
appendLine
(
sb,
"EXAMPLE: " + StringRoutines.cleanWhitespace(descriptionNode.getTextContent())
);
foundExample = true;
}
}
if (!foundExample)
System.err.println("WARNING: Found no example for one of the constructors of ludeme: " + node.fullType);
}
}
}
}
if (classCommentNode != null)
{
final List<Node> attributes = xmlChildrenForName(classCommentNode, "attribute");
// Write remarks
for (final Node attribute : attributes)
{
if (attribute.getAttributes().getNamedItem("name").getTextContent().equals("@remarks"))
{
final Node descriptionNode = xmlChildForName(attribute, "description");
appendLine(sb, "REMARKS: " + StringRoutines.cleanWhitespace(descriptionNode.getTextContent()));
}
}
}
}
/**
* Processes the given enum node
* @param node
* @param sb
*/
private static void processEnumNode(final ClassTreeNode node, final StringBuilder sb)
{
// We're starting a new enum type
appendLine(sb, "TYPE: " + node.fullType);
// Write the comments on top of enum
final Node commentNode = xmlChildForName(node.xmlNode, "comment");
if (commentNode != null)
{
final Node descriptionNode = xmlChildForName(commentNode, "description");
if (descriptionNode != null)
appendLine(sb, "TYPE JAVADOC: " + StringRoutines.cleanWhitespace(descriptionNode.getTextContent()));
}
// Write enum value comments
final Node enumerationNode = xmlChildForName(node.xmlNode, "enumeration");
final List<Node> values = xmlChildrenForName(enumerationNode, "value");
if (!values.isEmpty())
{
for (final Node valueNode : values)
{
final String valueName = valueNode.getAttributes().getNamedItem("name").getTextContent();
final Node descriptionNode = valueNode.getAttributes().getNamedItem("description");
final String description = (descriptionNode != null) ? descriptionNode.getTextContent() : null;
if (description == null)
System.err.println("WARNING: no javadoc for value " + valueName + " of enum: " + node.fullType);
else if (StringRoutines.cleanWhitespace(description).equals(""))
System.err.println("WARNING: empty javadoc for value " + valueName + " of enum: " + node.fullType);
if (description != null)
appendLine(sb, "CONST JAVADOC: " + valueName + ": " + description);
}
}
}
/**
* @param xmlNode
* @param name
* @return Child of given XML node with given name
*/
private static final Node xmlChildForName(final Node xmlNode, final String name)
{
final NodeList childNodes = xmlNode.getChildNodes();
for (int i = 0; i < childNodes.getLength(); ++i)
{
if (name.equals(childNodes.item(i).getNodeName()))
return childNodes.item(i);
}
return null;
}
/**
* @param xmlNode
* @param name
* @return Children of given XML node with given name
*/
private static final List<Node> xmlChildrenForName(final Node xmlNode, final String name)
{
final List<Node> ret = new ArrayList<Node>();
final NodeList childNodes = xmlNode.getChildNodes();
for (int i = 0; i < childNodes.getLength(); ++i)
{
if (name.equals(childNodes.item(i).getNodeName()))
ret.add(childNodes.item(i));
}
return ret;
}
/**
* @param type
* @return Generates a String for a given type, as it would also appear in grammar
*/
private static final String typeString(final String type)
{
final String str = StringRoutines.lowerCaseInitial(type);
if (str.equals("integer"))
return "int";
else if (str.equals("intFunction"))
return "<int>";
else if (str.equals("booleanFunction"))
return "<boolean>";
else if (str.equals("regionFunction"))
return "<region>";
return "<" + str + ">";
}
/**
* @param node
* @param type
* @return True if the given node contains an annotation of given type
*/
private static final boolean hasAnnotation(final Node node, final String type)
{
final Node annotationsNode = xmlChildForName(node, "annotations");
if (annotationsNode != null)
{
final List<Node> annotationNodes = xmlChildrenForName(annotationsNode, "annotation");
for (final Node annotationNode : annotationNodes)
{
final String annotationType = annotationNode.getAttributes().getNamedItem("type").getTextContent();
if (annotationType.equals(type))
return true;
}
}
return false;
}
/**
* Processes all our .def files
* @param sb
*/
private static final void processDefFiles(final StringBuilder sb)
{
// Get list of directories
final List<File> dirs = new ArrayList<File>();
final File folder = new File(DEFS_DIR);
dirs.add(folder);
for (int i = 0; i < dirs.size(); ++i)
{
final File dir = dirs.get(i);
for (final File file : dir.listFiles())
if (file.isDirectory())
dirs.add(file);
}
Collections.sort(dirs);
// Visit files in each directory
for (final File dir : dirs)
{
for (final File file : dir.listFiles())
if (!file.isDirectory())
processDefFile(file, sb);
}
}
/**
* Processes a single given .def file
* @param file
* @param sb
*/
private static final void processDefFile(final File file, final StringBuilder sb)
{
if (!file.getPath().contains(".def"))
{
System.err.println("Bad file: " + file.getPath());
return;
}
// Read lines in
final List<String> lines = new ArrayList<String>();
try
(
final BufferedReader reader =
new BufferedReader
(
new InputStreamReader
(
new FileInputStream(file),
StandardCharsets.UTF_8
)
)
)
{
String line = reader.readLine();
while (line != null)
{
lines.add(line);
line = reader.readLine();
}
}
catch (final IOException e)
{
e.printStackTrace();
}
// Write .def name
final String name = file.getName().substring(0, file.getName().length() - ".def".length());
appendLine(sb, "DEFINE: " + name);
// Write def comments
appendLine(sb, "DEFINE JAVADOC: " + commentsFromLines(lines));
// Write examples
for (final String example : examplesFromLines(lines))
{
appendLine(sb, "DEFINE EXAMPLE: " + StringRoutines.cleanWhitespace(example));
}
}
//-------------------------------------------------------------------------
final static String commentsFromLines(final List<String> lines)
{
final StringBuilder sb = new StringBuilder();
for (final String line : lines)
{
final int c = line.indexOf("//");
if (c < 0)
break; // not a comment
if (line.contains("@example"))
break; // don't include examples in comments
sb.append(line.substring(c + 2).trim() + " ");
}
return sb.toString();
}
//-------------------------------------------------------------------------
final static List<String> examplesFromLines(final List<String> lines)
{
final List<String> examples = new ArrayList<String>();
for (final String line : lines)
{
final int c = line.indexOf("@example");
if (c < 0)
continue; // not an example
examples.add(line.substring(c + 8).trim());
}
return examples;
}
//-------------------------------------------------------------------------
/**
* Appends given line to StringBuilder (+ newline character)
* @param sb
* @param line
*/
private static final void appendLine(final StringBuilder sb, final String line)
{
sb.append(line + "\n");
}
/**
* Makes sure all packages that are somewhere in the given list (including
* subpackages of these packages) are all nicely sorted: first classes,
* then subpackages, with each of those being sorted alphabetically.
* @param packages
*/
private static void sortPackages(final List<ClassTreeNode> packages)
{
packages.sort(new Comparator<ClassTreeNode>()
{
@Override
public int compare(final ClassTreeNode o1, final ClassTreeNode o2)
{
if (!o1.isPackage && o2.isPackage)
return -1;
if (o1.isPackage && !o2.isPackage)
return 1;
return o1.name.compareTo(o2.name);
}
});
for (final ClassTreeNode p : packages)
{
sortPackages(p.children);
}
}
/**
* Class for node in our tree of classes (and packages)
*
* @author Dennis Soemers
*/
private static class ClassTreeNode
{
/** Full package + type name */
public final String fullType;
/** Name of package or class */
public final String name;
/** True if we're a package, false if we're a class */
public boolean isPackage;
/** True if this is an enum (instead of a Ludeme class or package) */
public boolean isEnum;
/** The XML node */
public Node xmlNode;
/** List of child nodes (with subpackages and classes) */
public final List<ClassTreeNode> children = new ArrayList<ClassTreeNode>();
/**
* Constructor
* @param name
* @param isPackage
* @param fullType
* @param isEnum
* @param xmlNode
*/
public ClassTreeNode
(
final String name,
final boolean isPackage,
final String fullType,
final boolean isEnum,
final Node xmlNode
)
{
this.name = name;
this.isPackage = isPackage;
this.fullType = fullType;
this.isEnum = isEnum;
this.xmlNode = xmlNode;
}
@Override
public String toString()
{
return "[Node: " + fullType + "]";
}
}
}
| 28,267 | 27.815494 | 156 |
java
|
Ludii
|
Ludii-master/LudiiDocGen/src/main/GenerateLudiiEditorHelpFileMain.java
|
package main;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import org.xml.sax.SAXException;
import help.GenerateLudiiEditorHelpFile;
import xml.GenerateLudiiDocXML;
/**
* Main method to generate (an updated version of) the help file for
* tooltips/autocomplete in the Ludii editor.
*
* @author Dennis Soemers
*/
public class GenerateLudiiEditorHelpFileMain
{
/**
* Main method
* @param args
* @throws IOException
* @throws InterruptedException
* @throws SAXException
* @throws ParserConfigurationException
* @throws ClassNotFoundException
*/
public static void main(final String[] args)
throws InterruptedException, IOException, ClassNotFoundException,
ParserConfigurationException, SAXException
{
GenerateLudiiDocXML.generateXML();
GenerateLudiiEditorHelpFile.generateHelp();
}
}
| 869 | 21.307692 | 69 |
java
|
Ludii
|
Ludii-master/LudiiDocGen/src/main/GenerateLudiiLanguageReference.java
|
package main;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import org.xml.sax.SAXException;
import tex.GenerateLudiiDocTex;
import xml.GenerateLudiiDocXML;
/**
* Main method to go through full process for generating Ludii language reference
*
* @author Dennis Soemers
*/
public class GenerateLudiiLanguageReference
{
/**
* Main method
* @param args
* @throws IOException
* @throws InterruptedException
* @throws SAXException
* @throws ParserConfigurationException
* @throws ClassNotFoundException
*/
public static void main(final String[] args)
throws InterruptedException, IOException, ClassNotFoundException,
ParserConfigurationException, SAXException
{
GenerateLudiiDocXML.generateXML();
GenerateLudiiDocTex.generateTex();
}
}
| 817 | 20.526316 | 81 |
java
|
Ludii
|
Ludii-master/LudiiDocGen/src/tex/GenerateLudiiDocTex.java
|
package tex;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Modifier;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import gnu.trove.list.array.TIntArrayList;
import grammar.Grammar;
import graphics.svg.SVGLoader;
import main.Constants;
import main.StringRoutines;
import main.grammar.Description;
import main.grammar.Report;
import main.grammar.Symbol;
import main.grammar.Token;
import main.options.UserSelections;
import metadata.MetadataItem;
import other.Ludeme;
import parser.Parser;
//-----------------------------------------------------------------------------
/**
* Code to generate .tex files for Ludii Language Reference
*
* @author Dennis Soemers and cambolbro
*/
public class GenerateLudiiDocTex
{
private static final Grammar grammar = Grammar.grammar();
private static final int CHAPTER_GAME = 0;
private static final int CHAPTER_EQUIPMENT = 1;
private static final int CHAPTER_GRAPH_FUNCS = 2;
private static final int CHAPTER_DIM_FUNCS = 3;
private static final int CHAPTER_FLOAT_FUNCS = 4;
private static final int CHAPTER_RULES = 5;
private static final int CHAPTER_MOVES = 6;
private static final int CHAPTER_BOOLEAN_FUNCS = 7;
private static final int CHAPTER_INT_FUNCS = 8;
private static final int CHAPTER_INT_ARRAY_FUNCS = 9;
private static final int CHAPTER_REGION_FUNCS = 10;
private static final int CHAPTER_DIRECTION_FUNCS = 11;
private static final int CHAPTER_RANGE_FUNCS = 12;
private static final int CHAPTER_UTILITIES = 13;
private static final int CHAPTER_TYPES = 14;
private static final int CHAPTER_INFO_METADATA = 15;
private static final int CHAPTER_GRAPHICS_METADATA = 16;
private static final int CHAPTER_AI_METADATA = 17;
// private static final int CHAPTER_DEFINES = 15;
// private static final int CHAPTER_OPTIONS = 16;
// private static final int CHAPTER_RULESETS = 17;
// private static final int CHAPTER_RANGES = 18;
//
// private static final int APPENDIX_KNOWN_DEFINES = 19;
// private static final int APPENDIX_LUDII_GRAMMAR = 14;
private static final String[] CHAPTER_FILENAMES = new String[]
{
"out/tex/Chapter2GameLudemes.tex",
"out/tex/Chapter3Equipment.tex",
"out/tex/Chapter4GraphFuncs.tex",
"out/tex/Chapter5DimFuncs.tex",
"out/tex/Chapter6FloatFuncs.tex",
"out/tex/Chapter7Rules.tex",
"out/tex/Chapter8Moves.tex",
"out/tex/Chapter9BooleanFuncs.tex",
"out/tex/Chapter10IntFuncs.tex",
"out/tex/Chapter11IntArrayFuncs.tex",
"out/tex/Chapter12RegionFuncs.tex",
"out/tex/Chapter13DirectionFuncs.tex",
"out/tex/Chapter14RangeFuncs.tex",
"out/tex/Chapter15Utilities.tex",
"out/tex/Chapter16Types.tex",
"out/tex/Chapter17InfoMetadata.tex",
"out/tex/Chapter18GraphicsMetadata.tex",
"out/tex/Chapter19AIMetadata.tex",
// No! Overwrites source files
//"out/tex/ChapterXDefines.tex",
//"out/tex/ChapterXOptions.tex",
//"out/tex/ChapterXRulesets.tex",
//"out/tex/ChapterXRanges.tex",
//"out/tex/ChapterXConstants.tex",
//"out/tex/AppendixAKnownDefines.tex",
//"out/tex/AppendixBLudiiGrammar.tex",
};
private static final String[] CHAPTER_NAMES = new String[]
{
"Game",
"Equipment",
"Graph Functions",
"Dimension Functions",
"Float Functions",
"Rules",
"Moves",
"Boolean Functions",
"Integer Functions",
"Integer Array Functions",
"Region Functions",
"Direction Functions",
"Range Functions",
"Utilities",
"Types",
"Info Metadata",
"Graphics Metadata",
"AI Metadata",
"Defines",
"Options",
"Rulesets",
"Ranges",
"Constants",
"B -- Known Defines",
"A -- Ludii Grammar",
};
private static final String[] CHAPTER_LABELS = new String[]
{
"\\label{Chapter:GameLudemes}",
"\\label{Chapter:EquipmentLudemes}",
"\\label{Chapter:GraphFunctions}",
"\\label{Chapter:DimFunctions}",
"\\label{Chapter:FloatFunctions}",
"\\label{Chapter:RuleLudemes}",
"\\label{Chapter:MoveLudemes}",
"\\label{Chapter:BooleanLudemes}",
"\\label{Chapter:IntegerLudemes}",
"\\label{Chapter:IntegerArrayLudemes}",
"\\label{Chapter:RegionLudemes}",
"\\label{Chapter:DirectionLudemes}",
"\\label{Chapter:RangeLudemes}",
"\\label{Chapter:Utilities}",
"\\label{Chapter:Types}",
"\\label{Chapter:InfoMetadata}",
"\\label{Chapter:GraphicsMetadata}",
"\\label{Chapter:AIMetadata}",
"\\label{Chapter:Defines}",
"\\label{Chapter:Options}",
"\\label{Chapter:Rulesets}",
"\\label{Chapter:Ranges}",
"\\label{Chapter:Constants}",
"\\label{Appendix:KnownDefines}",
"\\label{Appendix:LudiiGrammar}",
};
/** Map from packages to chapters in which they should be included */
private static final Map<String, Integer> PACKAGE_TO_CHAPTER = new HashMap<String, Integer>();
static
{
PACKAGE_TO_CHAPTER.put("game", Integer.valueOf(CHAPTER_GAME));
PACKAGE_TO_CHAPTER.put("game.equipment", Integer.valueOf(CHAPTER_EQUIPMENT));
PACKAGE_TO_CHAPTER.put("game.functions.graph", Integer.valueOf(CHAPTER_GRAPH_FUNCS));
PACKAGE_TO_CHAPTER.put("game.functions.dim", Integer.valueOf(CHAPTER_DIM_FUNCS));
PACKAGE_TO_CHAPTER.put("game.functions.floats", Integer.valueOf(CHAPTER_FLOAT_FUNCS));
PACKAGE_TO_CHAPTER.put("game.functions.booleans", Integer.valueOf(CHAPTER_BOOLEAN_FUNCS));
PACKAGE_TO_CHAPTER.put("game.functions.intArray", Integer.valueOf(CHAPTER_INT_ARRAY_FUNCS));
PACKAGE_TO_CHAPTER.put("game.functions.ints", Integer.valueOf(CHAPTER_INT_FUNCS));
PACKAGE_TO_CHAPTER.put("game.functions.region", Integer.valueOf(CHAPTER_REGION_FUNCS));
PACKAGE_TO_CHAPTER.put("game.rules", Integer.valueOf(CHAPTER_RULES));
PACKAGE_TO_CHAPTER.put("game.rules.play.moves", Integer.valueOf(CHAPTER_MOVES));
PACKAGE_TO_CHAPTER.put("game.functions.directions", Integer.valueOf(CHAPTER_DIRECTION_FUNCS));
PACKAGE_TO_CHAPTER.put("game.functions.range", Integer.valueOf(CHAPTER_RANGE_FUNCS));
PACKAGE_TO_CHAPTER.put("game.types", Integer.valueOf(CHAPTER_TYPES));
PACKAGE_TO_CHAPTER.put("game.util", Integer.valueOf(CHAPTER_UTILITIES));
PACKAGE_TO_CHAPTER.put("metadata", Integer.valueOf(CHAPTER_INFO_METADATA));
PACKAGE_TO_CHAPTER.put("metadata.graphics", Integer.valueOf(CHAPTER_GRAPHICS_METADATA));
PACKAGE_TO_CHAPTER.put("metadata.ai", Integer.valueOf(CHAPTER_AI_METADATA));
}
/** Map from type descriptions in documentation strings to labels they should link to */
private static final Map<String, String> TYPE_TO_LABEL = new HashMap<String, String>();
static
{
TYPE_TO_LABEL.put("java.lang.Integer", "Sec:Introduction.Integers");
TYPE_TO_LABEL.put("java.lang.Boolean", "Sec:Introduction.Booleans");
TYPE_TO_LABEL.put("java.lang.Float", "Sec:Introduction.Floats");
TYPE_TO_LABEL.put("java.lang.String", "Sec:Introduction.Strings");
TYPE_TO_LABEL.put("game.equipment.container.board.shape.Shape", "Sec:game.equipment.container.board.shape");
TYPE_TO_LABEL.put("game.equipment.container.board.tiling.Tiling", "Sec:game.equipment.container.board.tiling.flat");
TYPE_TO_LABEL.put("game.equipment.container.board.tiling.flat.FlatTiling", "Sec:game.equipment.container.board.tiling.flat");
TYPE_TO_LABEL.put("game.equipment.container.board.tiling.pyramidal.PyramidalTiling", "Sec:game.equipment.container.board.tiling.pyramidal");
TYPE_TO_LABEL.put("game.equipment.container.board.modify.Modify", "Sec:game.equipment.container.board.modify");
TYPE_TO_LABEL.put("game.equipment.Item", "Chapter:EquipmentLudemes");
TYPE_TO_LABEL.put("game.functions.ints.IntFunction", "Chapter:IntegerLudemes");
TYPE_TO_LABEL.put("game.functions.intArray.IntArrayFunction", "Chapter:IntegerArrayLudemes");
TYPE_TO_LABEL.put("game.functions.booleans.BooleanFunction", "Chapter:BooleanLudemes");
TYPE_TO_LABEL.put("game.functions.range.RangeFunction", "Chapter:RangeLudemes");
TYPE_TO_LABEL.put("game.functions.region.RegionFunction", "Chapter:RegionLudemes");
TYPE_TO_LABEL.put("game.functions.directions.DirectionsFunction", "Chapter:DirectionLudemes");
TYPE_TO_LABEL.put("game.functions.graph.GraphFunction", "Chapter:GraphFunctions");
TYPE_TO_LABEL.put("game.functions.floats.FloatFunction", "Chapter:FloatFunctions");
TYPE_TO_LABEL.put("game.functions.dim.DimFunction", "Chapter:DimFunctions");
TYPE_TO_LABEL.put("game.rules.end.EndRule", "Sec:game.rules.end");
TYPE_TO_LABEL.put("game.rules.meta.MetaRule", "Sec:game.rules.meta");
TYPE_TO_LABEL.put("game.rules.play.moves.effect.Effects", "Sec:game.rules.play.moves.effect");
TYPE_TO_LABEL.put("game.rules.play.moves.Moves", "Chapter:MoveLudemes");
TYPE_TO_LABEL.put("game.rules.play.moves.nonDecision.NonDecision", "Chapter:MoveLudemes");
TYPE_TO_LABEL.put("game.rules.start.StartRule", "Sec:game.rules.start");
TYPE_TO_LABEL.put("game.util.directions.Direction", "Sec:game.util.directions");
TYPE_TO_LABEL.put("metadata.ai.heuristics.transformations.HeuristicTransformation", "Sec:metadata.ai.heuristics.transformations");
TYPE_TO_LABEL.put("metadata.ai.heuristics.terms.HeuristicTerm", "Sec:metadata.ai.heuristics.terms");
TYPE_TO_LABEL.put("metadata.graphics.Graphics", "Chapter:GraphicsMetadata");
TYPE_TO_LABEL.put("metadata.info.Info", "Chapter:InfoMetadata");
TYPE_TO_LABEL.put("metadata.info.InfoItem", "Sec:metadata.info.database");
}
/** Map of pieces of text to replace in documentation */
private static final Map<String, String> TEXT_TO_REPLACE = new HashMap<String, String>();
static
{
TEXT_TO_REPLACE.put("MAX_DISTANCE", "$" + Constants.MAX_DISTANCE + "$");
TEXT_TO_REPLACE.put("\\section{Ai}", "\\section{AI}");
TEXT_TO_REPLACE.put("\\\\url", "\\url");
TEXT_TO_REPLACE.put("\\\\texttt{", "\\texttt{");
TEXT_TO_REPLACE.put("$\\\\leq$", "$\\leq$");
TEXT_TO_REPLACE.put("$\\\\geq$", "$\\geq$");
TEXT_TO_REPLACE.put("$\\\\neq$", "$\\neq$");
TEXT_TO_REPLACE.put("\\\\frac{", "\\frac{");
TEXT_TO_REPLACE.put("\\\\exp(", "\\exp(");
TEXT_TO_REPLACE.put("\\\\tanh", "\\tanh");
}
/**
* For every package with package-info.java comments, a string containing its comments
* with @chapter annotation.
*/
private static final Map<String, String> CHAPTER_PACKAGE_INFOS = new HashMap<String, String>();
/**
* For every package with package-info.java comments, a string containing its comments
* without any specific annotations (or with @section annotations).
*/
private static final Map<String, String> SECTION_PACKAGE_INFOS = new HashMap<String, String>();
/** The Section that we're currently writing in (per chapter) */
private static String[] currentSections = new String[CHAPTER_NAMES.length];
/**
* Main method
* @throws ParserConfigurationException
* @throws SAXException
* @throws IOException
* @throws ClassNotFoundException
*/
public static void generateTex() throws ParserConfigurationException, SAXException, IOException, ClassNotFoundException
{
// First we'll read the XML file we generated
final File inputFile = new File("out/xml/jel.xml");
final DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
final DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
final Document doc = dBuilder.parse(inputFile);
final Element root = doc.getDocumentElement();
final List<ClassTreeNode> rootPackages = new ArrayList<ClassTreeNode>();
final List<Node> packageInfoNodes = xmlChildrenForName(root, "jelpackage");
for (final Node packageInfoNode : packageInfoNodes)
{
final Node commentNode = xmlChildForName(packageInfoNode, "comment");
if (commentNode != null)
{
final String type = packageInfoNode.getAttributes().getNamedItem("type").getTextContent();
final Node descriptionNode = xmlChildForName(commentNode, "description");
final List<String> sectionComments = new ArrayList<String>();
final List<String> chapterComments = new ArrayList<String>();
if (descriptionNode != null)
sectionComments.add(descriptionNode.getTextContent());
final List<Node> attributeNodes = xmlChildrenForName(commentNode, "attribute");
for (final Node attributeNode : attributeNodes)
{
final String attributeName = attributeNode.getAttributes().getNamedItem("name").getTextContent();
final String attributeDescription = xmlChildForName(attributeNode, "description").getTextContent();
if (attributeName.equals("@chapter"))
chapterComments.add(attributeDescription);
else if (attributeName.equals("@section"))
sectionComments.add(attributeDescription);
}
SECTION_PACKAGE_INFOS.put(type, StringRoutines.join("\n\n", sectionComments));
CHAPTER_PACKAGE_INFOS.put(type, StringRoutines.join("\n\n", chapterComments));
}
}
final List<Node> classNodes = xmlChildrenForName(root, "jelclass");
for (int i = 0; i < classNodes.size(); ++i)
{
final Node child = classNodes.get(i);
if (hasAnnotation(child, "Hide") || hasAnnotation(child, "ImpliedRule"))
continue;
final NamedNodeMap attributes = child.getAttributes();
final String packageStr = attributes.getNamedItem("package").getTextContent();
String type = attributes.getNamedItem("type").getTextContent();
final String fullType = packageStr + "." + type.replaceAll(Pattern.quote("."), Matcher.quoteReplacement("$"));
final Class<?> clazz = Class.forName(fullType);
if (!Ludeme.class.isAssignableFrom(clazz) && !MetadataItem.class.isAssignableFrom(clazz) && !clazz.isEnum())
continue; // We skip classes that are neither Ludemes nor enums
if ((clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) && !clazz.isEnum())
continue; // We skip interfaces and abstract classes
if (type.contains("."))
{
if (!clazz.isEnum())
{
System.out.println("Skipping inner class type: " + fullType);
continue;
}
else
{
// Need to get rid of outer class
final String[] typeSplit = type.split(Pattern.quote("."));
type = typeSplit[typeSplit.length - 1];
}
}
boolean grammarSymbolUsed = false;
final List<Symbol> grammarSymbols = grammar.symbolListFromClassName(type);
if (grammarSymbols != null)
{
for (final Symbol symbol : grammarSymbols)
{
if
(
symbol.usedInDescription()
||
symbol.usedInMetadata()
||
(clazz.isEnum() && symbol.usedInGrammar())
)
{
grammarSymbolUsed = true;
break;
}
}
}
if (!grammarSymbolUsed && !MetadataItem.class.isAssignableFrom(clazz))
{
System.out.println("Ignoring type not used in grammar: " + fullType);
continue;
}
final String[] subpackages = packageStr.split(Pattern.quote("."));
// Find matching package in our list of root packages
ClassTreeNode currentNode = null;
List<ClassTreeNode> currentPackages = rootPackages;
final List<String> fullTypeStrParts = new ArrayList<String>();
for (int j = 0; j < subpackages.length; ++j)
{
boolean foundPackage = false;
fullTypeStrParts.add(subpackages[j]);
for (final ClassTreeNode pckg : currentPackages)
{
if (subpackages[j].equals(pckg.name))
{
currentNode = pckg;
foundPackage = true;
break;
}
}
if (!foundPackage)
{
// Didn't find a match, so have to instantiate a new root package
currentNode = new ClassTreeNode(subpackages[j], true, StringRoutines.join(".", fullTypeStrParts), clazz.isEnum(), child);
currentPackages.add(currentNode);
}
currentPackages = currentNode.children;
}
// Create new node for this type
fullTypeStrParts.add(type);
currentPackages.add(new ClassTreeNode(type, false, attributes.getNamedItem("fulltype").getTextContent(), clazz.isEnum(), child));
}
// Try to nicely sort all packages; first classes in alphabetical order, then subpackages
sortPackages(rootPackages);
// Create StringBuilders in which to collect text for all our chapters
final StringBuilder[] chapterStrings = new StringBuilder[CHAPTER_FILENAMES.length];
for (int i = 0; i < chapterStrings.length; ++i)
{
chapterStrings[i] = new StringBuilder();
appendLine(chapterStrings[i], "\\chapter{" + CHAPTER_NAMES[i] + "} " + CHAPTER_LABELS[i]);
// Write package info for this chapter
String chapterPackageStr = null;
for (final String key : PACKAGE_TO_CHAPTER.keySet())
{
if (PACKAGE_TO_CHAPTER.get(key).intValue() == i)
{
chapterPackageStr = key;
break;
}
}
final String packageInfo = CHAPTER_PACKAGE_INFOS.get(chapterPackageStr);
if (packageInfo != null)
appendLine(chapterStrings[i], packageInfo);
}
// Process all our packages in a depth-first manner
for (final ClassTreeNode node : rootPackages)
{
process(node, chapterStrings);
}
// Postprocess all our full chapter strings to set up hyperlinks, fix type names,
// and replace other keywords that need replacing
for (int i = 0; i < chapterStrings.length; ++i)
{
final StringBuilder sb = chapterStrings[i];
while (true)
{
final int paramStartIdx = sb.indexOf("<TO_LINK:");
if (paramStartIdx < 0) // we're done with this chapter
break;
final int paramEndIdx = sb.indexOf(">", paramStartIdx);
String paramTypeStr = sb.substring(paramStartIdx, paramEndIdx);
paramTypeStr = paramTypeStr.substring("<TO_LINK:".length(), paramTypeStr.length());
if (paramTypeStr.endsWith("[]"))
paramTypeStr = paramTypeStr.substring(0, paramTypeStr.length() - "[]".length());
final String[] paramTypeStrSplit = paramTypeStr.split(Pattern.quote("."));
final String paramTypeText = typeString(StringRoutines.lowerCaseInitial(paramTypeStrSplit[paramTypeStrSplit.length - 1]));
final String labelToLink = TYPE_TO_LABEL.get(paramTypeStr);
final String replaceStr;
if (labelToLink == null)
{
// No hyperlink
replaceStr = paramTypeText;
System.out.println("no hyperlink for: " + paramTypeStr);
}
else
{
replaceStr = "\\hyperref[" + labelToLink + "]{" + paramTypeText + "}";
}
sb.replace(paramStartIdx, paramEndIdx + 1, replaceStr);
}
for (final String key : TEXT_TO_REPLACE.keySet())
{
while (true)
{
final int startIdx = sb.indexOf(key);
if (startIdx < 0) // we're done with this key in this chapter
break;
final int endIdx = startIdx + key.length();
sb.replace(startIdx, endIdx, TEXT_TO_REPLACE.get(key));
}
}
}
// Write all our chapter files
for (int i = 0; i < chapterStrings.length; ++i)
{
try (final PrintWriter writer = new PrintWriter(new File(CHAPTER_FILENAMES[i]), "UTF-8"))
{
writer.write(chapterStrings[i].toString());
}
}
// for (final ClassTreeNode p : rootPackages)
// {
// p.print(0);
// }
// Write our appendix with list of images
writeImageList();
// Write our appendix of known defines
writeKnownDefines();
// Write out appendix containing grammar
writeGrammar();
}
/**
* Processes the given node
* @param node
* @param chapterStrings
*/
private static void process(final ClassTreeNode node, final StringBuilder[] chapterStrings)
{
if (node.isPackage)
{
for (final ClassTreeNode child : node.children)
{
process(child, chapterStrings);
}
}
else
{
if (node.isEnum)
processEnumNode(node, chapterStrings);
else
processClassNode(node, chapterStrings);
}
}
/**
* Processes the given class node
* @param node
* @param chapterStrings
*/
private static void processClassNode(final ClassTreeNode node, final StringBuilder[] chapterStrings)
{
// First figure out index of chapter in which we should write for this node
int chapter = -1;
String chapterPackages = node.fullType;
while (chapter < 0)
{
if (PACKAGE_TO_CHAPTER.containsKey(chapterPackages))
chapter = PACKAGE_TO_CHAPTER.get(chapterPackages).intValue();
else
chapterPackages = chapterPackages.substring(0, chapterPackages.lastIndexOf("."));
}
final StringBuilder sb = chapterStrings[chapter];
// Section headers will be based on what we didn't use for identifying chapter
final String sectionHeader = sectionHeader(chapterPackages + ".", node.fullType, chapter);
if (!sectionHeader.equals(currentSections[chapter]))
{
// We need to start writing a new section
currentSections[chapter] = sectionHeader;
final String packageStr = node.fullType.substring(0, node.fullType.length() - node.name.length() - 1);
final String packageInfo = SECTION_PACKAGE_INFOS.get(packageStr);
final String secLabelStr;
if (packageStr.contains(".") && !PACKAGE_TO_CHAPTER.containsKey(packageStr))
secLabelStr = packageStr;
else
secLabelStr = node.fullType + "." + node.name;
// System.out.println();
// System.out.println("node.fullType = " + node.fullType);
// System.out.println("node.name = " + node.name);
// System.out.println("packageStr = " + packageStr);
// System.out.println("sectionHeader = " + sectionHeader);
// System.out.println("secLabelStr = " + secLabelStr);
// System.out.println("chapter = " + chapter);
// System.out.println();
appendLine(sb, "");
//ruledLine(sb, 2);
appendLine(sb, "\\newpage");
appendLine(sb, "\\section{" + sectionHeader + "} \\label{Sec:" + secLabelStr + "}");
// Insert package info
if (packageInfo != null)
appendLine(sb, SECTION_PACKAGE_INFOS.get(packageStr));
else
System.err.println("null package info for: " + packageStr);
}
ruledLine(sb, 0.5);
//appendLine(sb, "\\newpage");
// Start a new subsection for specific ludeme
final String ludemeName = StringRoutines.lowerCaseInitial(node.name);
String subsectionHeader = ludemeName;
String alias = null;
String unformattedAlias = null;
// Check if we should modify subsection header due to @Alias annotation
if (hasAnnotation(node.xmlNode, "Alias"))
{
final Node annotationsNode = xmlChildForName(node.xmlNode, "annotations");
if (annotationsNode != null)
{
final List<Node> annotationNodes = xmlChildrenForName(annotationsNode, "annotation");
for (final Node annotationNode : annotationNodes)
{
final String annotationType = annotationNode.getAttributes().getNamedItem("type").getTextContent();
if (annotationType.equals("Alias"))
{
final Node valuesNode = xmlChildForName(annotationNode, "values");
final Node valueNode = xmlChildForName(valuesNode, "value");
alias = valueNode.getAttributes().getNamedItem("value").getTextContent();
unformattedAlias = alias;
alias = "$" + alias + "$";
alias = alias.replaceAll(Pattern.quote("%"), Matcher.quoteReplacement("\\%"));
alias = alias.replaceAll(Pattern.quote("^"), Matcher.quoteReplacement("\\wedge{}"));
subsectionHeader = "\\texorpdfstring{" + alias + "}{} (" + ludemeName + ")";
break;
}
}
}
}
appendLine(sb, "");
appendLine(sb, "\\subsection{" + subsectionHeader + "} \\label{Subsec:" + node.fullType + "}");
TYPE_TO_LABEL.put(node.fullType, "Subsec:" + node.fullType);
// First write the comments on top of class
final Node classCommentNode = xmlChildForName(node.xmlNode, "comment");
if (classCommentNode != null)
{
final Node descriptionNode = xmlChildForName(classCommentNode, "description");
if (descriptionNode != null)
{
if (descriptionNode.getTextContent().charAt(descriptionNode.getTextContent().length() - 1) != '.')
System.err.println("WARNING: comment with no full stop for the description of " + ludemeName);
appendLine(sb, descriptionNode.getTextContent());
}
}
// Add a separating line before "Format" box
// sb.append("\n\\phantom{}\n\n");
// Write the constructors
final Node methodsNode = xmlChildForName(node.xmlNode, "methods");
final List<Node> constructors = xmlChildrenForName(methodsNode, "constructor");
// also add public static create() methods to the constructors
final List<Node> createMethods = xmlChildrenForName(methodsNode, "method");
for (final Node methodNode : createMethods)
{
final Node staticAttribute = methodNode.getAttributes().getNamedItem("static");
if
(
staticAttribute != null &&
staticAttribute.getTextContent().equals("true") &&
methodNode.getAttributes().getNamedItem("visibility").getTextContent().equals("public") &&
methodNode.getAttributes().getNamedItem("name").getTextContent().equals("construct")
)
{
constructors.add(methodNode);
}
}
// Remove constructors with @Hide annotations
constructors.removeIf((final Node ctor) -> { return hasAnnotation(ctor, "Hide"); });
// Remove non-public constructors
constructors.removeIf((final Node ctor) ->
{
return !ctor.getAttributes().getNamedItem("visibility").getTextContent().equals("public");
});
if (constructors.size() >= 1)
{
appendLine(sb, "\\vspace{-1mm}");
appendLine(sb, "\\subsubsection*{Format}");
}
// This will collect examples over all constructors
final List<Node> exampleDescriptionNodes = new ArrayList<Node>();
for (int ctorIdx = 0; ctorIdx < constructors.size(); ++ctorIdx)
{
final Node ctor = constructors.get(ctorIdx);
appendLine(sb, "\\begin{formatbox}");
if (constructors.size() > 1)
{
// Need to add constructor-level javadoc
final Node commentNode = xmlChildForName(ctor, "comment");
if (commentNode != null)
{
final Node descriptionNode = xmlChildForName(commentNode, "description");
if (descriptionNode != null)
{
final String description = descriptionNode.getTextContent();
if (description.length() > 0)
appendLine(sb, description + "\n\n\\vspace{.2cm}\n");
else
System.err.println("WARNING: No Javadoc comment for " + (ctorIdx + 1) + "th constructor of " + node.fullType);
if (description.toLowerCase().contains("constructor"))
System.err.println("WARNING: Javadoc comment for " + (ctorIdx + 1) + "th constructor of " + node.fullType + " uses the word Constructor!");
}
else
{
System.err.println("WARNING: No Javadoc comment for " + (ctorIdx + 1) + "th constructor of " + node.fullType);
}
}
else
{
System.err.println("WARNING: No Javadoc comment for " + (ctorIdx + 1) + "th constructor of " + node.fullType);
}
}
appendLine(sb, "\\noindent\\begin{minipage}{\\textwidth}");
final StringBuilder ctorSb = new StringBuilder();
appendLine(sb, "\\begin{ttquote}");
//appendLine(sb, "\\noindent");
appendLine(sb, "\\hspace{-7mm}");
if (alias != null)
ctorSb.append("(" + alias + "");
else
ctorSb.append("(" + ludemeName + "");
final Node paramsNode = xmlChildForName(ctor, "params");
final List<String> paramSymbols = new ArrayList<String>();
final TIntArrayList singleValueEnumParamIndices = new TIntArrayList();
if (paramsNode != null)
{
final List<Node> paramNodes = xmlChildrenForName(paramsNode, "param");
boolean orSequence = false;
boolean or2Sequence = false;
for (int paramNodeIdx = 0; paramNodeIdx < paramNodes.size(); ++paramNodeIdx)
{
final Node paramNode = paramNodes.get(paramNodeIdx);
// Figure out how to write this param
final String paramName = paramNode.getAttributes().getNamedItem("name").getTextContent();
String paramFullType = paramNode.getAttributes().getNamedItem("fulltype").getTextContent();
boolean named = false;
boolean optional = false;
int numArrayDims = 0;
boolean startNewOrSequence = false;
boolean endPreviousOrSequence = (orSequence || or2Sequence);
while (paramFullType.endsWith("[]"))
{
paramFullType = paramFullType.substring(0, paramFullType.length() - "[]".length());
numArrayDims += 1;
}
final Node annotationsNode = xmlChildForName(paramNode, "annotations");
if (annotationsNode != null)
{
final List<Node> annotationNodes = xmlChildrenForName(annotationsNode, "annotation");
for (final Node annotationNode : annotationNodes)
{
final String annotationType = annotationNode.getAttributes().getNamedItem("type").getTextContent();
if (annotationType.equals("Name"))
{
named = true;
}
else if (annotationType.equals("Opt"))
{
optional = true;
}
else if (annotationType.equals("Or"))
{
if (orSequence)
endPreviousOrSequence = false;
else
startNewOrSequence = true;
orSequence = true;
or2Sequence = false;
}
else if (annotationType.equals("Or2"))
{
if (or2Sequence)
endPreviousOrSequence = false;
else
startNewOrSequence = true;
orSequence = false;
or2Sequence = true;
}
}
}
if (endPreviousOrSequence)
{
orSequence = false;
or2Sequence = false;
ctorSb.append(")");
}
// Write this param
ctorSb.append(" ");
if (startNewOrSequence)
ctorSb.append("(");
else if (orSequence || or2Sequence)
ctorSb.append(" | ");
final StringBuilder paramSymbolSb = new StringBuilder();
if (optional)
paramSymbolSb.append("[");
if (named)
paramSymbolSb.append(StringRoutines.lowerCaseInitial(paramName) + ":");
for (int i = 0; i < numArrayDims; ++i)
{
paramSymbolSb.append("\\{");
}
try
{
final Class<?> paramClass = Class.forName(paramFullType);
if (Enum.class.isAssignableFrom(paramClass))
{
if (paramClass.getEnumConstants().length == 1)
{
paramSymbolSb.append(paramClass.getEnumConstants()[0].toString());
singleValueEnumParamIndices.add(paramNodeIdx);
}
else
{
paramSymbolSb.append("<TO_LINK:" + paramFullType + ">");
}
}
else
{
paramSymbolSb.append("<TO_LINK:" + paramFullType + ">");
}
}
catch (final ClassNotFoundException e)
{
e.printStackTrace();
}
for (int i = 0; i < numArrayDims; ++i)
{
paramSymbolSb.append("\\}");
}
if (optional)
paramSymbolSb.append("]");
paramSymbols.add(paramSymbolSb.toString());
ctorSb.append(paramSymbolSb);
}
if (orSequence || or2Sequence) // close final or sequence
ctorSb.append(")");
}
ctorSb.append(")");
appendLine(sb, ctorSb.toString());
appendLine(sb, "\\end{ttquote}");
if (paramSymbols.size() > 0)
appendLine(sb, "\\vspace{\\parskip}");
appendLine(sb, "\\end{minipage}");
if (paramSymbols.size() - singleValueEnumParamIndices.size() > 0)
{
// Add explanations of all the params
appendLine(sb, "\\noindent where:");
appendLine(sb, "\\begin{itemize}");
final List<Node> paramNodes = xmlChildrenForName(paramsNode, "param");
for (int paramNodeIdx = 0; paramNodeIdx < paramNodes.size(); ++paramNodeIdx)
{
if (singleValueEnumParamIndices.contains(paramNodeIdx))
{
// Skip this param, it's a single-value enum
continue;
}
final Node paramNode = paramNodes.get(paramNodeIdx);
final Node commentNode = paramNode.getAttributes().getNamedItem("comment");
if (commentNode == null)
System.err.println("WARNING: No Javadoc comment for " + (paramNodeIdx + 1) + "th param of " + (ctorIdx + 1) + "th constructor of " + node.fullType);
else if (StringRoutines.cleanWhitespace(commentNode.getTextContent()).equals(""))
System.err.println("WARNING: Empty Javadoc comment for " + (paramNodeIdx + 1) + "th param of " + (ctorIdx + 1) + "th constructor of " + node.fullType);
else if (commentNode.getTextContent().charAt(commentNode.getTextContent().length() - 1) != '.')
System.err.println("WARNING: comment with no full stop for " + (paramNodeIdx + 1)
+ "th param of " + (ctorIdx + 1) + "th constructor of " + node.fullType);
final String paramDescription = commentNode != null ? commentNode.getTextContent() : "";
appendLine(sb, "\\item \\texttt{" + paramSymbols.get(paramNodeIdx) + "}: " + paramDescription);
final int openSquareBracketIdx = paramDescription.indexOf("[");
if (openSquareBracketIdx >= 0)
{
final int closingSquareBracketIdx = StringRoutines.matchingBracketAt(paramDescription, openSquareBracketIdx);
if (closingSquareBracketIdx < 0)
{
System.err.println("WARNING: No closing square bracket in " + (paramNodeIdx + 1) + "th param of " + (ctorIdx + 1) + "th constructor of " + node.fullType);
}
}
}
appendLine(sb, "\\end{itemize}");
}
final Node ctorCommentNode = xmlChildForName(ctor, "comment");
if (ctorCommentNode != null)
{
final List<Node> attributes = xmlChildrenForName(ctorCommentNode, "attribute");
// Collect constructor-specific examples
boolean foundExample = false;
for (final Node attribute : attributes)
{
if (attribute.getAttributes().getNamedItem("name").getTextContent().equals("@example"))
{
final Node descriptionNode = xmlChildForName(attribute, "description");
exampleDescriptionNodes.add(descriptionNode);
foundExample = true;
}
}
if (!foundExample)
System.err.println("WARNING: Found no example for one of the constructors of ludeme: " + node.fullType);
// We don't want to support constructor-specific remarks anymore
for (final Node attribute : attributes)
{
if (attribute.getAttributes().getNamedItem("name").getTextContent().equals("@remarks"))
System.err.println("WARNING: Found constructor-specific remark in ludeme: " + ludemeName);
}
}
appendLine(sb, "\\vspace{.2cm}");
appendLine(sb, "\\end{formatbox}");
if (ctorIdx + 1 < constructors.size())
appendLine(sb, "\\phantom{}");
appendLine(sb, "");
}
// Collect nodes with remarks to print here
final List<Node> remarkNodes = new ArrayList<Node>();
// And same for images
final List<Node> imageNodes = new ArrayList<Node>();
if (classCommentNode != null)
{
final List<Node> attributes = xmlChildrenForName(classCommentNode, "attribute");
// Collect class-wide examples
for (final Node attribute : attributes)
{
if (attribute.getAttributes().getNamedItem("name").getTextContent().equals("@example"))
{
final Node descriptionNode = xmlChildForName(attribute, "description");
exampleDescriptionNodes.add(descriptionNode);
}
}
// Collect remarks
for (final Node attribute : attributes)
{
if (attribute.getAttributes().getNamedItem("name").getTextContent().equals("@remarks"))
{
final Node descriptionNode = xmlChildForName(attribute, "description");
if (descriptionNode.getTextContent().charAt(descriptionNode.getTextContent().length() - 1) != '.')
System.err.println("WARNING: comment with no full stop for the remarks of " + ludemeName);
remarkNodes.add(descriptionNode);
}
}
// Collect images
for (final Node attribute : attributes)
{
if (attribute.getAttributes().getNamedItem("name").getTextContent().equals("@image"))
{
final Node descriptionNode = xmlChildForName(attribute, "description");
imageNodes.add(descriptionNode);
}
}
}
if (exampleDescriptionNodes.size() > 0)
{
appendLine(sb, "\\vspace{-2mm}");
if (exampleDescriptionNodes.size() == 1)
appendLine(sb, "\\subsubsection*{Example}");
else
appendLine(sb, "\\subsubsection*{Examples}");
appendLine(sb, "\\begin{formatbox}");
appendLine(sb, "\\noindent\\begin{minipage}{\\textwidth}");
for (final Node exampleNode : exampleDescriptionNodes)
{
final Report report = new Report();
final Token token = new Token(exampleNode.getTextContent(), report);
String exampleCode = token.toString();
// Try to compile our example code
Object compiledObject = null;
try
{
final Description description = new Description(exampleCode);
final String className = node.fullType;
final String symbolName;
if (unformattedAlias == null)
{
final String[] classNameSplit = className.split(Pattern.quote("."));
symbolName = StringRoutines.lowerCaseInitial(classNameSplit[classNameSplit.length - 1]);
}
else
{
symbolName = unformattedAlias;
}
//Expander.expand(description, new UserSelections(new ArrayList<String>()), report, false);
Parser.expandAndParse
(
description,
new UserSelections(new ArrayList<String>()),
report,
true, // allow examples
false
);
compiledObject = compiler.Compiler.compileObject(description.expanded(), symbolName, className, report);
if (report.isWarning())
{
System.err.println("Encountered warnings compiling example code:");
System.err.println(exampleCode);
System.err.println();
for (final String warning : report.warnings())
{
System.err.println(warning);
}
}
if (report.isError())
{
System.err.println("Encountered errors compiling example code:");
System.err.println(exampleCode);
System.err.println();
for (final String error : report.errors())
{
System.err.println(error);
}
}
//compiledObject = compiler.Compiler.compileObject(exampleCode, node.fullType);
}
catch (final Exception e)
{
// Do nothing
}
if (exampleCode.endsWith("\n"))
exampleCode = exampleCode.substring(0, exampleCode.lastIndexOf('\n'));
if (compiledObject == null)
{
System.err.println("Failed to compile example code in " + ludemeName);
System.err.println("Expected type = " + node.fullType);
System.err.println("Example code: \n" + exampleCode);
System.err.println("exampleNode.getTextContent() = " + exampleNode.getTextContent());
}
appendLine(sb, "\\begin{verbatim}");
// TO PRINT ALL THE EXAMPLES UNCOMMENT THAT.
// System.out.println(exampleNode.getTextContent() + "\n");
appendLine(sb, exampleCode);
appendLine(sb, "\\end{verbatim}");
}
appendLine(sb, "\\end{minipage}");
if (exampleDescriptionNodes.size() > 1)
appendLine(sb, "\\vspace{.2cm}");
else
appendLine(sb, "\\vspace{.001cm}");
appendLine(sb, "\\end{formatbox}");
appendLine(sb, "");
}
for (final Node remarksNode : remarkNodes)
{
appendLine(sb, "");
appendLine(sb, "\\vspace{-2mm}");
appendLine(sb, "\\subsubsection*{Remarks}");
appendLine(sb, remarksNode.getTextContent());
}
if (imageNodes.size() > 0)
{
appendLine(sb, "");
appendLine(sb, "\\subsection*{Images}");
for (final Node imageNode : imageNodes)
{
final String contents = imageNode.getTextContent();
final int startIdxFilepath = contents.indexOf("IMAGE=");
final int startIdxCaption = contents.indexOf("CAPTION=");
final int startIdxLabel = contents.indexOf("LABEL=");
if (startIdxFilepath < 0)
{
System.err.println("WARNING: Image filepath not found for image in ludeme: " + node.fullType);
continue;
}
if (startIdxCaption < 0)
{
System.err.println("WARNING: Image caption not found for image in ludeme: " + node.fullType);
continue;
}
if (startIdxLabel < startIdxCaption || startIdxCaption < startIdxFilepath)
{
System.err.println("WARNING: Ignoring image for ludeme: " + node.fullType + ". We require file first, then caption, then (optionally) label.");
continue;
}
appendLine(sb, "\\begin{figure} [H]");
appendLine(sb, "\\centering");
final int endIdxFilepath;
if (startIdxLabel >= 0)
endIdxFilepath = Math.min(startIdxCaption, startIdxLabel);
else
endIdxFilepath = startIdxCaption;
appendLine(sb, "\\includegraphics[max height=6cm,max width=\\textwidth]{" + contents.substring(startIdxFilepath + "IMAGE=".length(), endIdxFilepath).trim() + "}");
final int endIdxCaption = (startIdxLabel >= 0) ? startIdxLabel : contents.length();
appendLine(sb, "\\caption{" + contents.substring(startIdxCaption + "CAPTION=".length(), endIdxCaption).trim() + "}");
if (startIdxLabel >= 0)
appendLine(sb, "\\label{" + contents.substring(startIdxLabel + "LABEL=".length(), contents.length()).trim() + "}");
appendLine(sb, "\\end{figure}");
}
}
// if (exampleDescriptionNodes.size() > 0 || remarkNodes.size() > 0)
// ruledLine(sb);
}
static void ruledLine(final StringBuilder sb, final double width)
{
appendLine(sb, "");
appendLine(sb, "\\vskip10pt");
appendLine(sb, "\\noindent\\rule{\\textwidth}{" + width + "pt}");
appendLine(sb, "\\vskip0pt");
appendLine(sb, "\\vspace{-2mm}");
}
/**
* Processes the given enum node
* @param node
* @param chapterStrings
*/
private static void processEnumNode(final ClassTreeNode node, final StringBuilder[] chapterStrings)
{
// First figure out index of chapter in which we should write for this node
int chapter = -1;
String chapterPackages = node.fullType;
while (chapter < 0)
{
if (PACKAGE_TO_CHAPTER.containsKey(chapterPackages))
chapter = PACKAGE_TO_CHAPTER.get(chapterPackages).intValue();
else
chapterPackages = chapterPackages.substring(0, chapterPackages.lastIndexOf("."));
}
final StringBuilder sb = chapterStrings[chapter];
// Section headers will be based on what we didn't use for identifying chapter
final String sectionHeader = sectionHeader(chapterPackages + ".", node.fullType, chapter);
final String currentSection = currentSections[chapter];
if (!sectionHeader.equals(currentSection))
{
// We need to start writing a new section
currentSections[chapter] = sectionHeader;
appendLine(sb, "");
ruledLine(sb, 0.5);
//appendLine(sb, "\\newpage");
final String packageStr = node.fullType.substring(0, node.fullType.length() - node.name.length() - 1);
final String secLabelStr;
if (packageStr.contains(".") && !PACKAGE_TO_CHAPTER.containsKey(packageStr))
secLabelStr = packageStr;
else
secLabelStr = node.fullType + "." + node.name;
appendLine(sb, "\\section{" + sectionHeader + "} \\label{Sec:" + secLabelStr + "}");
final String packageInfo = SECTION_PACKAGE_INFOS.get(packageStr);
// Insert package info
if (packageInfo != null)
appendLine(sb, SECTION_PACKAGE_INFOS.get(packageStr));
else
System.err.println("null package info for: " + packageStr);
}
// Start a new subsection for specific enum
final String ludemeName = StringRoutines.lowerCaseInitial(node.name);
appendLine(sb, "");
appendLine(sb, "\\subsection{" + ludemeName + "} \\label{Subsec:" + node.fullType + "}");
TYPE_TO_LABEL.put(node.fullType, "Subsec:" + node.fullType);
// First write the comments on top of class
final Node commentNode = xmlChildForName(node.xmlNode, "comment");
if (commentNode != null)
{
final Node descriptionNode = xmlChildForName(commentNode, "description");
if (descriptionNode != null)
appendLine(sb, descriptionNode.getTextContent());
}
// Write enum values
final Node enumerationNode = xmlChildForName(node.xmlNode, "enumeration");
appendLine(sb, "");
// appendLine(sb, "\\subsubsection*{Type values}");
// appendLine(sb, "\\vspace{-4mm}");
final List<Node> values = xmlChildrenForName(enumerationNode, "value");
if (!values.isEmpty())
{
appendLine(sb, "\\renewcommand{\\arraystretch}{1.3}");
appendLine(sb, "\\arrayrulecolor{white}");
appendLine(sb, "\\rowcolors{2}{gray!25}{gray!10}");
appendLine(sb, "\\begin{longtable}{@{}p{.2\\textwidth} | p{.76\\textwidth}@{}}");
appendLine(sb, "\\rowcolor{gray!50}");
appendLine(sb, "\\textbf{Value} & \\textbf{Description} \\\\");
for (final Node valueNode : values)
{
String valueName = valueNode.getAttributes().getNamedItem("name").getTextContent();
valueName = valueName.replaceAll(Pattern.quote("_"), Matcher.quoteReplacement("\\_")); // escape underscores
final Node descriptionNode = valueNode.getAttributes().getNamedItem("description");
final String description = (descriptionNode != null) ? descriptionNode.getTextContent() : null;
if (description == null)
System.err.println("WARNING: no javadoc for value " + valueName + " of enum: " + node.fullType);
else if (StringRoutines.cleanWhitespace(description).equals(""))
System.err.println("WARNING: empty javadoc for value " + valueName + " of enum: " + node.fullType);
if (description == null)
appendLine(sb, valueName + " & \\\\");
else
appendLine(sb, valueName + " & " + description + " \\\\");
}
appendLine(sb, "\\end{longtable}");
}
}
/**
* @param prefixToRemove Prefix from fullType that we'll remove before determining section header
* @param fullType
* @param chapter
* @return Section header for node with given full type in given chapter
*/
private static final String sectionHeader(final String prefixToRemove, final String fullType, final int chapter)
{
String sectionHeaderStr = fullType.replace(prefixToRemove, "");
final int lastDotIdx = sectionHeaderStr.lastIndexOf(".");
if (lastDotIdx >= 0)
sectionHeaderStr = sectionHeaderStr.substring(0, lastDotIdx);
final String[] sectionHeaderParts = sectionHeaderStr.split(Pattern.quote("."));
String sectionHeader = StringRoutines.join(" - ", StringRoutines.upperCaseInitialEach(sectionHeaderParts));
if (sectionHeader.length() == 0)
{
// We'll just reuse the chapter name as section header
sectionHeader = CHAPTER_NAMES[chapter];
}
return sectionHeader;
}
/**
* @param xmlNode
* @param name
* @return Child of given XML node with given name
*/
private static final Node xmlChildForName(final Node xmlNode, final String name)
{
final NodeList childNodes = xmlNode.getChildNodes();
for (int i = 0; i < childNodes.getLength(); ++i)
{
if (name.equals(childNodes.item(i).getNodeName()))
return childNodes.item(i);
}
return null;
}
/**
* @param xmlNode
* @param name
* @return Children of given XML node with given name
*/
private static final List<Node> xmlChildrenForName(final Node xmlNode, final String name)
{
final List<Node> ret = new ArrayList<Node>();
final NodeList childNodes = xmlNode.getChildNodes();
for (int i = 0; i < childNodes.getLength(); ++i)
{
if (name.equals(childNodes.item(i).getNodeName()))
ret.add(childNodes.item(i));
}
return ret;
}
/**
* @param type
* @return Generates a String for a given type, as it would also appear in grammar
*/
private static final String typeString(final String type)
{
final String str = StringRoutines.lowerCaseInitial(type);
if (str.equals("integer"))
return "int";
else if (str.equals("intFunction"))
return "<int>";
else if (str.equals("booleanFunction"))
return "<boolean>";
else if (str.equals("regionFunction"))
return "<region>";
return "<" + str + ">";
}
/**
* @param node
* @param type
* @return True if the given node contains an annotation of given type
*/
private static final boolean hasAnnotation(final Node node, final String type)
{
final Node annotationsNode = xmlChildForName(node, "annotations");
if (annotationsNode != null)
{
final List<Node> annotationNodes = xmlChildrenForName(annotationsNode, "annotation");
for (final Node annotationNode : annotationNodes)
{
final String annotationType = annotationNode.getAttributes().getNamedItem("type").getTextContent();
if (annotationType.equals(type))
return true;
}
}
return false;
}
/**
* Writes our appendix with list of images
*/
private static void writeImageList()
{
final String imageAppendixFilepath = "out/tex/AppendixAImageList.tex";
final StringBuilder sb = new StringBuilder();
// Write introductory part
appendLine(sb, "% WARNING: Do NOT manually modify this file! Instead modify writeImageList() in GenerateLudiiDocTex.java!");
appendLine(sb, "");
appendLine(sb, "\\chapter{Image List} \\label{Appendix:ImageList}");
appendLine(sb, "\\fancyhead[C]{\\leftmark}");
appendLine(sb, "");
appendLine(sb, "This Appendix lists the image files provided with the Ludii distribution.");
appendLine(sb, "These image names can be used in .lud files to associate particular images with named pieces "
+ "or board symbols.");
appendLine(sb, "For pieces, the app tries to find the image whose file name is closest to the defined name, e.g. "
+ "``QueenLeft'' will match the image file ``queen.svg''.");
appendLine(sb, "For board symbols, an exact name match is required.");
appendLine(sb, "");
appendLine(sb, "\\phantom{}");
appendLine(sb, "");
appendLine(sb, "\\noindent");
appendLine(sb, "Credits for images appear in the About dialog for games in which they are used.");
appendLine(sb, "");
appendLine(sb, "\\phantom{}");
appendLine(sb, "");
appendLine(sb, "\\noindent");
appendLine(sb, "Image list as of Ludii v" + Constants.LUDEME_VERSION + ".");
appendLine(sb, "");
appendLine(sb, "\\vspace{3mm}");
appendLine(sb, "\\noindent\\rule{\\textwidth}{2pt}");
appendLine(sb, "\\vspace{-6mm}");
appendLine(sb, "");
appendLine(sb, "\\begin{multicols}{2}");
final String[] svgs = SVGLoader.listSVGs();
String currSubsec = null;
for (final String svg : svgs)
{
final String[] svgSplit = svg.replaceAll(Pattern.quote("/svg/"), "").split(Pattern.quote("/"));
final String subsec = StringRoutines.join("/", Arrays.copyOf(svgSplit, svgSplit.length - 1));
if (!subsec.equals(currSubsec))
{
currSubsec = subsec;
appendLine(sb, "\\subsection*{" + subsec + "}");
appendLine(sb, "\\hspace{4mm}");
}
appendLine(sb, svgSplit[svgSplit.length - 1].replaceAll(Pattern.quote("_"), Matcher.quoteReplacement("\\_")));
appendLine(sb, "");
}
appendLine(sb, "\\end{multicols}");
try (final PrintWriter writer = new PrintWriter(new File(imageAppendixFilepath), "UTF-8"))
{
writer.write(sb.toString());
}
catch (final FileNotFoundException | UnsupportedEncodingException e)
{
e.printStackTrace();
}
}
private static void writeKnownDefines()
{
final String definesAppendixFilepath = "out/tex/AppendixBKnownDefines.tex";
final StringBuilder sb = new StringBuilder();
// Write introductory part
appendLine(sb, "% WARNING: Do NOT manually modify this file! Instead modify writeKnownDefines() in "
+ "GenerateLudiiDocTex.java!");
appendLine(sb, "");
appendLine(sb, "\\chapter{Known Defines} \\label{Appendix:KnownDefines}");
appendLine(sb, "");
appendLine(sb, "This Appendix lists the known {\\tt define} structures provided with the Ludii distribution, "
+ "which are available for use by game authors. ");
appendLine(sb, "Known defines can be found in the ``def'' package area (or below) with file extension *.def.");
appendLine(sb, "See Chapter~\\ref{Chapter:Defines} for details on the {\\tt define} syntax.");
appendLine(sb, "");
appendLine(sb, "\\vspace{3mm}");
appendLine(sb, "\\noindent\\rule{\\textwidth}{2pt}");
appendLine(sb, "\\vspace{-7mm}");
appendLine(sb, "");
appendLine(sb, convertAllDefToTex("../Common/res/def"));
try (final PrintWriter writer = new PrintWriter(new File(definesAppendixFilepath), "UTF-8"))
{
writer.write(sb.toString());
}
catch (final FileNotFoundException | UnsupportedEncodingException e)
{
e.printStackTrace();
}
}
private static void writeGrammar()
{
final String grammarAppendixFilepath = "out/tex/AppendixCLudiiGrammar.tex";
final StringBuilder sb = new StringBuilder();
// Write introductory part
appendLine(sb, "% WARNING: Do NOT manually modify this file! Instead modify writeGrammar() in "
+ "GenerateLudiiDocTex.java!");
appendLine(sb, "");
appendLine(sb, "\\chapter{Ludii Grammar} \\label{Appendix:LudiiGrammar}");
appendLine(sb, "This Appendix lists the complete Ludii grammar for the current Ludii version.");
appendLine(sb, "The Ludii grammar is generated automatically from the hierarchy of Java classes that implement "
+ "the ludemes described in this document, using the {\\it class grammar} approach described in "
+ "C. Browne ``A Class Grammar for General Games'', {\\it Computers and Games (CG 2016)}, "
+ "Springer, LNCS 10068, pp.~169--184.");
appendLine(sb, "");
appendLine(sb, "Ludii game descriptions (*.lud files) {\\it must} conform to this grammar, but note that "
+ "conformance does not guarantee compilation. ");
appendLine(sb, "Many factors can stop game descriptions from compiling, such as attempting to access a "
+ "component using an undefined name, attempting to modify board sites that do not exist, and so on.");
appendLine(sb, "");
appendLine(sb, "%====================================================================");
appendLine(sb, "");
appendLine(sb, "\\section{Compilation}");
appendLine(sb, "");
appendLine(sb, "The steps for compiling a game according to the grammar, from a given *.lud game description "
+ "to an executable Java {\\tt Game} object, are as follows:");
appendLine(sb, "");
appendLine(sb, "\\begin{enumerate}");
appendLine(sb, "");
appendLine(sb, "\\item {\\it Expand}: The {\\it raw} text *.lud game description is expanded according to "
+ "the metalanguage features described in Part~\\ref{Part:MetalanguageFeatures} "
+ "(defines, options, rulesets, ranges, constants, etc.) to give an {\\it expanded} text description "
+ "of the game with current options and rulesets instantiated.");
appendLine(sb, "");
appendLine(sb, "\\item {\\it Tokenise}: The expanded text description is then {\\it tokenised} into a "
+ "{\\it symbolic expression} in the form of a tree of simple tokens.");
appendLine(sb, "");
appendLine(sb, "\\item {\\it Parse}: The token tree is parsed according to the current Ludii grammar for "
+ "correctness.");
appendLine(sb, "");
appendLine(sb, "\\item {\\it Compile}: The names of tokens in the token tree are then matched with known "
+ "ludeme Java classes and these are compiled with the specified arguments, if possible, to give "
+ "a {\\tt Game} object.");
appendLine(sb, "");
appendLine(sb, "\\item {\\it Create}: The {\\tt Game} object calls its {\\tt create()} method to perform "
+ "relevant preparations, such as deciding on an appropriate {\tt State} type, allocating required "
+ "memory, initialising necessary variables, etc. ");
appendLine(sb, "");
appendLine(sb, "\\end{enumerate}");
appendLine(sb, "");
appendLine(sb, "%====================================================================");
appendLine(sb, "");
appendLine(sb, "%\\section{Error Handling}");
appendLine(sb, "");
appendLine(sb, "% TODO: Notes on error handling.");
appendLine(sb, "");
appendLine(sb, "%====================================================================");
appendLine(sb, "");
appendLine(sb, "\\section{Listing}");
appendLine(sb, "");
appendLine(sb, "\\vspace{-2mm}");
appendLine(sb, "");
appendLine(sb, "\\begingroup");
appendLine(sb, "\\obeylines");
appendLine(sb, "{\\tt \\small");
appendLine(sb, "\\begin{verbatim}");
appendLine(sb, "");
appendLine(sb, Grammar.grammar().toString());
appendLine(sb, "");
appendLine(sb, "\\end{verbatim}");
appendLine(sb, "}");
appendLine(sb, "\\endgroup");
try (final PrintWriter writer = new PrintWriter(new File(grammarAppendixFilepath), "UTF-8"))
{
writer.write(sb.toString());
}
catch (final FileNotFoundException | UnsupportedEncodingException e)
{
e.printStackTrace();
}
}
//-------------------------------------------------------------------------
/**
* Converts all .def into .tex from the specified folder and below.
* @return
*/
private static String convertAllDefToTex(final String folderPath)
{
final StringBuilder sb = new StringBuilder();
// Get list of directories
final List<File> dirs = new ArrayList<File>();
final File folder = new File(folderPath);
dirs.add(folder);
for (int i = 0; i < dirs.size(); ++i)
{
final File dir = dirs.get(i);
for (final File file : dir.listFiles())
if (file.isDirectory())
dirs.add(file);
}
Collections.sort(dirs);
try
{
// Visit files in each directory
for (final File dir : dirs)
{
final String path = dir.getCanonicalPath().replaceAll(Pattern.quote("\\"), "/");
if (path.indexOf("/def/") != -1)
{
// Add this section header
final String name = path.substring(path.indexOf("def/"));
sb.append(texSection(name));
}
for (final File file : dir.listFiles())
if (!file.isDirectory())
convertDefToTex(file, sb);
}
}
catch (final IOException e)
{
e.printStackTrace();
}
return sb.toString();
}
//-------------------------------------------------------------------------
/**
* Converts the specified .def file to .tex.
*/
private static void convertDefToTex(final File file, final StringBuilder sb)
{
if (!file.getPath().contains(".def"))
{
System.err.println("Bad file: " + file.getPath());
return;
}
// Read lines in
final List<String> lines = new ArrayList<String>();
try
(
final BufferedReader reader =
new BufferedReader
(
new InputStreamReader
(
new FileInputStream(file),
StandardCharsets.UTF_8
)
)
)
{
String line = reader.readLine();
while (line != null)
{
// Process line for .tex safety
line = line.replace("&", "\\&");
line = line.replace("_", "\\_");
lines.add(new String(line));
line = reader.readLine();
}
}
catch (final IOException e)
{
e.printStackTrace();
}
// Handle subsection title for this define
final String name = file.getName().substring(0, file.getName().length() - 4);
sb.append(texSubsection(name));
// Handle comments in description
final String comments = commentsFromLines(lines);
if (comments == "")
sb.append("\\phantom{}\n");
else
sb.append("\n" + comments + "\n");
// Handle examples
final List<String> examples = examplesFromLines(lines);
if (!examples.isEmpty())
sb.append(texExample(examples));
// Handle define
final String define = defineFromLines(lines);
sb.append(texDefine(define));
}
//-------------------------------------------------------------------------
private final static String commentsFromLines(final List<String> lines)
{
final StringBuilder sb = new StringBuilder();
int commentLinesAdded = 0;
for (final String line : lines)
{
final int c = line.indexOf("//");
if (c < 0)
break; // not a comment
if (line.contains("@example"))
break; // don't include examples in comments
if (commentLinesAdded > 0)
sb.append(" \\\\ ");
sb.append(line.substring(c + 2).trim() + " ");
commentLinesAdded++;
}
final String comments = sb.toString().replace("#", "\\#");
return comments;
}
//-------------------------------------------------------------------------
private final static List<String> examplesFromLines(final List<String> lines)
{
final List<String> examples = new ArrayList<String>();
for (final String line : lines)
{
final int c = line.indexOf("@example");
if (c < 0)
continue; // not an example
examples.add(line.substring(c + 8).trim());
}
return examples;
}
//-------------------------------------------------------------------------
private final static String defineFromLines(final List<String> lines)
{
final StringBuilder sb = new StringBuilder();
boolean defineFound = false;
for (final String line : lines)
{
final int c = line.indexOf("(define ");
if (c >= 0)
defineFound = true;
if (defineFound)
sb.append(line + "\n");
}
return sb.toString();
}
//-------------------------------------------------------------------------
private static String texThinLine()
{
final StringBuilder sb = new StringBuilder();
sb.append("\n" + "\\vspace{-1mm}\n");
sb.append("\\noindent\\rule{\\textwidth}{0.5pt}\n");
sb.append("\\vspace{-6mm}\n");
return sb.toString();
}
private static String texThickLine()
{
final StringBuilder sb = new StringBuilder();
sb.append("\n" + "\\vspace{3mm}\n");
sb.append("\\noindent\\rule{\\textwidth}{2pt}\n");
sb.append("\\vspace{-7mm}\n");
return sb.toString();
}
private static String texSection(final String title)
{
final StringBuilder sb = new StringBuilder();
sb.append("\n" + "%==========================================================\n");
sb.append(texThickLine());
sb.append("\n" + "\\section{" + title + "}\n");
//sb.append("\n" + "%---------------------------------\n");
return sb.toString();
}
private static String texSubsection(final String name)
{
final StringBuilder sb = new StringBuilder();
sb.append("\n" + "%-----------------------------------------\n");
sb.append(texThinLine());
sb.append("\n" + "\\subsection{``" + name + "''}");
sb.append(" \\label{known:" + name + "}\n");
return sb.toString();
}
private static String texExample(final List<String> examples)
{
final StringBuilder sb = new StringBuilder();
if (examples.size() < 2)
sb.append("\n% Example\n");
else
sb.append("\n% Examples\n");
sb.append("\\vspace{-1mm}\n");
sb.append("\\subsubsection*{Example}\n");
sb.append("\\vspace{-3mm}\n");
sb.append("\n" + "\\begin{formatbox}\n");
sb.append("\\begin{verbatim}\n");
for (final String example : examples)
sb.append(example + "\n");
sb.append("\\end{verbatim}\n");
sb.append("\\vspace{-1mm}\n");
sb.append("\\end{formatbox}\n");
sb.append("\\vspace{-2mm}\n");
return sb.toString();
}
private static String texDefine(final String define)
{
final StringBuilder sb = new StringBuilder();
sb.append("\n% Define\n");
sb.append("{\\tt\n");
sb.append("\\begin{verbatim}\n");
sb.append(define + "\n");
sb.append("\\end{verbatim}\n");
sb.append("}\n");
sb.append("\\vspace{-4mm}\n");
return sb.toString();
}
//-------------------------------------------------------------------------
/**
* Appends given line to StringBuilder (+ newline character)
* @param sb
* @param line
*/
private static final void appendLine(final StringBuilder sb, final String line)
{
sb.append(line + "\n");
}
/**
* Makes sure all packages that are somewhere in the given list (including
* subpackages of these packages) are all nicely sorted: first classes,
* then subpackages, with each of those being sorted alphabetically.
* @param packages
*/
private static void sortPackages(final List<ClassTreeNode> packages)
{
packages.sort(new Comparator<ClassTreeNode>()
{
@Override
public int compare(final ClassTreeNode o1, final ClassTreeNode o2)
{
if (!o1.isPackage && o2.isPackage)
return -1;
if (o1.isPackage && !o2.isPackage)
return 1;
return o1.name.compareToIgnoreCase(o2.name);
}
});
for (final ClassTreeNode p : packages)
{
sortPackages(p.children);
}
}
/**
* Class for node in our tree of classes (and packages)
*
* @author Dennis Soemers
*/
private static class ClassTreeNode
{
/** Full package + type name */
public final String fullType;
/** Name of package or class */
public final String name;
/** True if we're a package, false if we're a class */
public boolean isPackage;
/** True if this is an enum (instead of a Ludeme class or package) */
public boolean isEnum;
/** The XML node */
public Node xmlNode;
/** List of child nodes (with subpackages and classes) */
public final List<ClassTreeNode> children = new ArrayList<ClassTreeNode>();
/**
* Constructor
* @param name
* @param isPackage
* @param fullType
* @param isEnum
* @param xmlNode
*/
public ClassTreeNode
(
final String name,
final boolean isPackage,
final String fullType,
final boolean isEnum,
final Node xmlNode
)
{
this.name = name;
this.isPackage = isPackage;
this.fullType = fullType;
this.isEnum = isEnum;
this.xmlNode = xmlNode;
}
// /**
// * Prints this package and all subpackages
// * @param numIndents
// */
// protected void print(final int numIndents)
// {
// final StringBuilder sb = new StringBuilder();
// for (int i = 0; i < numIndents; ++i)
// {
// sb.append("\t");
// }
// sb.append(name);
// System.out.println(sb);
//
// for (final ClassTreeNode child : children)
// {
// child.print(numIndents + 1);
// }
// }
@Override
public String toString()
{
return "[Node: " + fullType + "]";
}
}
}
| 66,269 | 32.019432 | 167 |
java
|
Ludii
|
Ludii-master/LudiiDocGen/src/xml/GenerateLudiiDocXML.java
|
package xml;
import java.io.File;
import java.io.IOException;
import java.util.regex.Pattern;
import main.StringRoutines;
/**
* Code to generate XML representation of Ludii's
* javadoc documentation.
*
* @author Dennis Soemers
*/
public class GenerateLudiiDocXML
{
/** Filepath for our doclet JAR file */
private static final String DOCLET_FILEPATH = "../LudiiDocGen/lib/jeldoclet.jar";
/** Filepath for directory where we want to write XML Javadoc output */
private static final String XML_OUT_DIR = "../LudiiDocGen/out/xml";
/** Classpath (with class files) */
private static final String CLASSPATH = StringRoutines.join
(
File.pathSeparator,
"../Common/bin",
"../Common/lib/Trove4j_ApacheCommonsRNG.jar",
"../Language/bin",
"../Core/lib/jfreesvg-3.4.jar"
);
/** Sourcepath (with source files) */
private static final String SOURCEPATH = "../Core/src";
/**
* Main method
* @throws IOException
* @throws InterruptedException
*/
public static void generateXML() throws InterruptedException, IOException
{
final String executableName;
if (new File("C:/Program Files/Java/jdk1.8.0_301/bin/javadoc.exe").exists())
{
// Hardcoding this filepath for Dennis' desktop because otherwise Eclipse
// uses the wrong javadoc (the one packaged with Eclipse, which is version 13
// and incompatible with our doclet)
executableName = "C:/Program Files/Java/jdk1.8.0_301/bin/javadoc";
}
else
{
executableName = "javadoc";
}
final String command =
StringRoutines.join
(
" ",
executableName,
"-doclet",
"com.jeldoclet.JELDoclet",
"-docletpath",
new File(DOCLET_FILEPATH).getCanonicalPath(),
"-d",
new File(XML_OUT_DIR).getCanonicalPath(),
"-classpath",
CLASSPATH,
"-sourcepath",
new File(SOURCEPATH).getCanonicalPath(),
"-subpackages",
"game:metadata",
"-public",
"-encoding",
"UTF-8"//,
//"-verbose"
);
// System.out.println("where javadoc:");
// new ProcessBuilder("where javadoc".split(Pattern.quote(" "))).inheritIO().start().waitFor();
System.out.println("Executing command: " + command);
new ProcessBuilder(command.split(Pattern.quote(" "))).inheritIO().start().waitFor();
}
}
| 2,264 | 24.738636 | 96 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/Manager.java
|
package manager;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.rng.core.RandomProviderDefaultState;
import main.Constants;
import manager.ai.AIDetails;
import manager.network.DatabaseFunctionsPublic;
import manager.network.SettingsNetwork;
import manager.utils.SettingsManager;
import other.AI;
import other.move.Move;
import tournament.Tournament;
/**
* The Manager class provides the link between the logic (Core/Referee) and the playerDesktop.
* I handles all aspects of Ludii that are not specific to the PC environment, e.g. Graphics2D.
*
* @author Matthew.Stephenson and cambolbro and Eric.Piette
*/
public final class Manager
{
private PlayerInterface playerInterface;
private final DatabaseFunctionsPublic databaseFunctionsPublic = DatabaseFunctionsPublic.construct();
/** Referee object that controls play. */
private final Referee ref;
/** Selects AI, based on player's choices in the Settings menu. */
private final AIDetails[] aiSelected = new AIDetails[Constants.MAX_PLAYERS + 1];
/** Our current tournament */
private Tournament tournament;
/** Internal state of Context's RNG at the beginning of the game currently in the App. */
private RandomProviderDefaultState currGameStartRngState = null;
/** References to AIs for which we're visualising what they're thinking live. */
private List<AI> liveAIs = null;
/** lud filename for the last loaded game. */
private String savedLudName;
/** list of the undoneMoves when viewing previous game states. */
private List<Move> undoneMoves = new ArrayList<>();
private final SettingsManager settingsManager = new SettingsManager();
private final SettingsNetwork settingsNetwork = new SettingsNetwork();
private boolean webApp = false;
//-------------------------------------------------------------------------
public Manager(final PlayerInterface playerInterface)
{
setPlayerInterface(playerInterface);
ref = new Referee();
}
//-------------------------------------------------------------------------
public Referee ref()
{
return ref;
}
public AIDetails[] aiSelected()
{
return aiSelected;
}
public Tournament tournament()
{
return tournament;
}
//-------------------------------------------------------------------------
public void updateCurrentGameRngInternalState()
{
setCurrGameStartRngState((RandomProviderDefaultState) ref().context().rng().saveState());
}
public RandomProviderDefaultState currGameStartRngState()
{
return currGameStartRngState;
}
public void setCurrGameStartRngState(final RandomProviderDefaultState newCurrGameStartRngState)
{
currGameStartRngState = newCurrGameStartRngState;
}
//-------------------------------------------------------------------------
/**
* @return The AIs for which we're visualising the thought process live
*/
public List<AI> liveAIs()
{
return liveAIs;
}
/**
* Sets the AIs for which we're visualising the thought process live
*
* @param ais
*/
public void setLiveAIs(final List<AI> ais)
{
liveAIs = ais;
}
//-------------------------------------------------------------------------
public String savedLudName()
{
return savedLudName;
}
public void setSavedLudName(final String savedLudName)
{
this.savedLudName = savedLudName;
}
//-------------------------------------------------------------------------
public void setUndoneMoves(final List<Move> moves)
{
undoneMoves = moves;
}
public List<Move> undoneMoves()
{
return undoneMoves;
}
//-------------------------------------------------------------------------
public SettingsManager settingsManager()
{
return settingsManager;
}
//-------------------------------------------------------------------------
public SettingsNetwork settingsNetwork()
{
return settingsNetwork;
}
//-------------------------------------------------------------------------
public PlayerInterface getPlayerInterface()
{
return playerInterface;
}
public void setPlayerInterface(final PlayerInterface playerInterface)
{
this.playerInterface = playerInterface;
}
//-------------------------------------------------------------------------
public Tournament getTournament()
{
return tournament;
}
public void setTournament(final Tournament tournament)
{
this.tournament = tournament;
}
//-------------------------------------------------------------------------
public DatabaseFunctionsPublic databaseFunctionsPublic()
{
return databaseFunctionsPublic;
}
//-------------------------------------------------------------------------
public boolean isWebApp()
{
return webApp;
}
public void setWebApp(final boolean webPlayer)
{
webApp = webPlayer;
}
//-------------------------------------------------------------------------
public int moverToAgent()
{
return ref().context().state().playerToAgent(ref().context().state().mover());
}
public int playerToAgent(final int i)
{
return ref().context().state().playerToAgent(i);
}
//-------------------------------------------------------------------------
}
| 5,129 | 23.084507 | 101 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/PlayerInterface.java
|
package manager;
import java.util.List;
import org.json.JSONObject;
import other.context.Context;
import other.move.Move;
/**
* Interface for specifying functions within the PlayerApp, which can be called from within the Manager project.
*
* @author Matthew.Stephenson
*/
public interface PlayerInterface
{
JSONObject getNameFromJar();
JSONObject getNameFromJson();
JSONObject getNameFromAiDef();
void loadGameFromName(final String name, final List<String> options, final boolean debug);
void addTextToStatusPanel(final String text);
void addTextToAnalysisPanel(final String text);
void selectAnalysisTab();
void repaint();
void reportForfeit(int playerForfeitNumber);
void reportTimeout(int playerForfeitNumber);
void reportDrawAgreed();
void updateFrameTitle(boolean alsoUpdateMenu);
void updateTabs(Context context);
void restartGame();
void repaintTimerForPlayer(int playerId);
void setTemporaryMessage(final String text);
void refreshNetworkDialog();
void postMoveUpdates(Move move, boolean noAnimation);
}
| 1,039 | 27.888889 | 112 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/Referee.java
|
package manager;
import java.awt.EventQueue;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicBoolean;
import org.json.JSONObject;
import game.Game;
import game.rules.play.moves.Moves;
import game.types.play.ModeType;
import main.Constants;
import manager.ai.AIDetails;
import manager.ai.AIUtil;
import other.AI;
import other.context.Context;
import other.model.Model;
import other.model.Model.AgentMoveCallback;
import other.model.Model.MoveMessageCallback;
import other.move.Move;
import other.trial.Trial;
import utils.AIUtils;
import utils.DoNothingAI;
/**
* The Referee class coordinates all aspects of game play including self-play
* tournaments.
*
* @author cambolbro and Eric.Piette and Matthew.Stephenson
*/
public class Referee
{
//---------------------------------------------------------
/** The game instance. */
Context context;
/** True if human input is allowed to cause a new step to start */
final AtomicBoolean allowHumanBasedStepStart = new AtomicBoolean(true);
/** Set to true if we want a new nextMove(false) call */
final AtomicBoolean wantNextMoveCall = new AtomicBoolean(false);
/** Update visualisation of what AI is thinking every x milliseconds */
public static final int AI_VIS_UPDATE_TIME = 40;
/** Thread for checking model to make moves. */
private RefereeStepThread moveThread = null;
//-------------------------------------------------------------------------
/**
* @return Current context
*/
public Context context()
{
return context;
}
//-------------------------------------------------------------------------
/**
* @param game
* @return The current game object.
*/
public Referee setGame(final Manager manager, final Game game)
{
context = new Context(game, new Trial(game));
manager.updateCurrentGameRngInternalState();
return this;
}
//-------------------------------------------------------------------------
/**
* Apply a saved move to the game. Used only when viewing prior states. No
* validity checks.
*/
public void makeSavedMoves(final Manager manager, final List<Move> moves)
{
Move move = null;
for (int i = context.trial().numMoves(); i < moves.size(); i++)
{
move = moves.get(i);
preMoveApplication(manager, move);
context.game().apply(context, move);
}
if (move != null)
postMoveApplication(manager, move, true);
}
//-------------------------------------------------------------------------
/**
* Apply human move to game.
*/
public synchronized void applyHumanMoveToGame(final Manager manager, final Move move)
{
final Model model = context.model();
if (model.isReady())
if (!nextMove(manager, true))
return;
final boolean autoPass = move.isPass() && context.game().moves(context).moves().isEmpty();
if (!autoPass)
{
while (model.isReady() || !model.isRunning())
{
try
{
Thread.sleep(10L);
}
catch (final InterruptedException e)
{
e.printStackTrace();
}
}
}
// Wrap the code that we want to run in a Runnable.
final Runnable runnable = () ->
{
preMoveApplication(manager, move);
final Move appliedMove = model.applyHumanMove(context(), move, move.mover());
if (model.movesPerPlayer() != null)
{
// We might be waiting for the moves of other players.
final ArrayList<Integer> playerIdsWaitingFor = new ArrayList<>();
for (int i = 1; i < model.movesPerPlayer().length; i++)
{
final Move m = model.movesPerPlayer()[i];
if (m == null)
playerIdsWaitingFor.add(Integer.valueOf(i));
}
if (playerIdsWaitingFor.size() > 0)
{
String tempMessage = "Waiting for moves from";
for (final int index : playerIdsWaitingFor)
tempMessage += " P" + index + " and";
tempMessage = tempMessage.substring(0, tempMessage.length()-4);
tempMessage += ".\n";
manager.getPlayerInterface().addTextToStatusPanel(tempMessage);
}
}
if (appliedMove != null)
postMoveApplication(manager, appliedMove, false);
};
runnable.run();
}
//-------------------------------------------------------------------------
/**
* Apply remote move that we received from the network.
*/
public synchronized boolean applyNetworkMoveToGame(final Manager manager, final Move move)
{
// Check that the model is ready to apply this move.
final Model model = context.model();
if (model.isReady() && !nextMove(manager, true))
{
System.out.println("Waiting on the model: " + move);
return false;
}
// Get the real move from the set of legal moves that matches the fetched move information.
final Move realMoveToApply = context.game().getMatchingLegalMove(context, move);
// If the move was not valid, tell the user and try again
if (realMoveToApply == null)
{
manager.getPlayerInterface().addTextToStatusPanel("received move was not legal: " + move + "\n");
manager.getPlayerInterface().addTextToStatusPanel("currentTrialLength: " + context.trial().moveNumber() + "\n");
return false;
}
// If the move was valid, try and apply it.
applyHumanMoveToGame(manager, realMoveToApply);
return true;
}
//-------------------------------------------------------------------------
/**
* Plays a random move in the current position.
*/
public void randomMove(final Manager manager)
{
final Moves legal = context.game().moves(context);
if (legal.moves().size() > 0)
{
final int moveIndex = ThreadLocalRandom.current().nextInt(0, legal.moves().size());
final Move randomMove = legal.get(moveIndex);
applyHumanMoveToGame(manager, randomMove);
}
}
//-------------------------------------------------------------------------
/**
* Time random playouts.
*
* @return Average number of playouts per second.
*/
public double timeRandomPlayouts()
{
// Use a copy of our context for all the playouts
final Context timingContext = new Context(context);
final Game game = timingContext.game();
// Warming
long stopAt = 0;
long start = System.nanoTime();
double abortAt = start + 10 * 1000000000.0;
while (stopAt < abortAt)
{
game.start(timingContext);
game.playout(timingContext, null, 1.0, null, 0, -1, ThreadLocalRandom.current());
stopAt = System.nanoTime();
}
stopAt = 0;
System.gc();
start = System.nanoTime();
abortAt = start + 30 * 1000000000.0;
int playouts = 0;
int moveDone = 0;
while (stopAt < abortAt)
{
game.start(timingContext);
game.playout(timingContext, null, 1.0, null, 0, -1, ThreadLocalRandom.current());
stopAt = System.nanoTime();
moveDone += timingContext.trial().numMoves();
playouts++;
}
final double secs = (stopAt - start) / 1000000000.0;
final double rate = (playouts / secs);
final double rateMove = (moveDone / secs);
System.out.println(String.format(Locale.US, "%.2f", Double.valueOf(rate)) + "p/s");
System.out.println(String.format(Locale.US, "%.2f", Double.valueOf(rateMove)) + "m/s");
return rate;
}
//-------------------------------------------------------------------------
/**
* Perform a random playout.
*/
public void randomPlayout(final Manager manager)
{
interruptAI(manager);
final Game gameToPlayout = context.game();
gameToPlayout.playout(context, null, 1.0, null, 0, -1, ThreadLocalRandom.current());
EventQueue.invokeLater(() ->
{
manager.getPlayerInterface().postMoveUpdates(context.trial().lastMove(), true);
});
}
/**
* Perform a random playout only for the current instance within a Match
*/
public void randomPlayoutSingleInstance(final Manager manager)
{
final Context instanceContext = context.currentInstanceContext();
final Trial instanceTrial = instanceContext.trial();
if (!instanceTrial.over())
{
interruptAI(manager);
final Trial startInstanceTrial = context.currentInstanceContext().trial();
int currentMovesMade = startInstanceTrial.numMoves();
// if (manager.savedTrial() != null)
// {
// final List<Move> tempActions = context.trial().generateCompleteMovesList();
// manager.getPlayerInterface().restartGame();
// makeSavedMoves(manager, tempActions);
// }
final Game gameToPlayout = instanceContext.game();
gameToPlayout.playout(instanceContext, null, 1.0, null, 0, -1, ThreadLocalRandom.current());
// Will likely have to append some extra moves to the match-wide trial
final List<Move> subtrialMoves = instanceContext.trial().generateCompleteMovesList();
final int numMovesAfterPlayout = subtrialMoves.size();
final int numMovesToAppend = numMovesAfterPlayout - currentMovesMade;
for (int i = 0; i < numMovesToAppend; ++i)
context.trial().addMove(subtrialMoves.get(subtrialMoves.size() - numMovesToAppend + i));
// If the instance we over, we have to advance here in this Match
if (instanceTrial.over())
{
final Moves legalMatchMoves = context.game().moves(context);
assert (legalMatchMoves.moves().size() == 1);
assert (legalMatchMoves.moves().get(0).containsNextInstance());
context.game().apply(context, legalMatchMoves.moves().get(0));
}
// We only want to print moves in moves tab from the last trial
if (context().currentInstanceContext().trial() != startInstanceTrial)
currentMovesMade = context().currentInstanceContext().trial().numInitialPlacementMoves();
}
}
//-------------------------------------------------------------------------
/**
* Triggers a move from the next player. If the next player is human then
* control drops through to wait for input.
*
* @param humanBasedStepStart True if the caller responds to human input
* @return True if we started a new step in the model
*/
public synchronized boolean nextMove(final Manager manager, final boolean humanBasedStepStart)
{
wantNextMoveCall.set(false);
if (!allowHumanBasedStepStart.get() && humanBasedStepStart)
return false;
try
{
if (!context().trial().over())
{
final Model model = context.model();
// In case of a simulation.
if (context.game().mode().mode().equals(ModeType.Simulation))
{
final List<AI> list = new ArrayList<AI>();
list.add(new DoNothingAI());
model.unpauseAgents
(
context,
list,
new double[]{ manager.settingsManager().tickLength() },
Constants.UNDEFINED,
Constants.UNDEFINED,
0.0,
null,
null,
true,
new MoveMessageCallback()
{
@Override
public void call(final String message)
{
manager.getPlayerInterface().addTextToStatusPanel(message);
}
}
);
postMoveApplication(manager, context.trial().lastMove(), false);
}
if (!model.isReady() && model.isRunning() && !manager.settingsManager().agentsPaused())
{
final double[] thinkTime = AIDetails.convertToThinkTimeArray(manager.aiSelected());
List<AI> agents = null;
if (!manager.settingsManager().agentsPaused())
agents = AIDetails.convertToAIList(manager.aiSelected());
if (agents != null)
AIUtil.checkAISupported(manager, context);
model.unpauseAgents
(
context,
agents,
thinkTime,
-1, -1,
0.4,
new AgentMoveCallback()
{
@Override
public long call(final Move move)
{
preMoveApplication(manager, move);
return 0L;
}
},
new AgentMoveCallback()
{
@Override
public long call(final Move move)
{
postMoveApplication(manager, move, false);
return -1L;
}
},
true,
new MoveMessageCallback()
{
@Override
public void call(final String message)
{
manager.getPlayerInterface().addTextToStatusPanel(message);
}
}
);
}
else
{
allowHumanBasedStepStart.set(model.expectsHumanInput());
if (moveThread != null && moveThread.isAlive())
moveThread.runnable.shouldTerminate = true;
moveThread = new RefereeStepThread(new RefereeStepRunnable()
{
@Override
public void run()
{
final double[] thinkTime = AIDetails.convertToThinkTimeArray(manager.aiSelected());
List<AI> agents = null;
if (!manager.settingsManager().agentsPaused())
{
agents = AIDetails.convertToAIList(manager.aiSelected());
}
// make sure any AIs are initialised
if (agents != null)
{
for (int p = 1; p <= context.game().players().count(); ++p)
{
if (agents.get(p) == null)
continue;
if (!agents.get(p).supportsGame(context.game()))
{
final AI oldAI = manager.aiSelected()[p].ai();
final AI newAI = AIUtils.defaultAiForGame(context.game());
final JSONObject json = new JSONObject()
.put("AI", new JSONObject()
.put("algorithm", newAI.friendlyName())
);
manager.aiSelected()[p] = new AIDetails(manager, json, p, "Ludii AI");
EventQueue.invokeLater(() ->
{
manager.getPlayerInterface().addTextToStatusPanel
(
oldAI.friendlyName() + " does not support this game. Switching to default AI for this game: "
+
newAI.friendlyName() + ".\n"
);
});
}
agents.get(p).initIfNeeded(context.game(), p);
}
}
final Trial startInstanceTrial = context.currentInstanceContext().trial();
model.startNewStep
(
context,
agents,
thinkTime,
-1, -1,
manager.settingsManager().minimumAgentThinkTime(),
false, // don't block
true, // force use of threads
false, // don't force use of no threads
new AgentMoveCallback()
{
@Override
public long call(final Move move)
{
preMoveApplication(manager, move);
return 0L;
}
},
new AgentMoveCallback()
{
@Override
public long call(final Move move)
{
postMoveApplication(manager, move, false);
return -1L;
}
},
true,
new MoveMessageCallback()
{
@Override
public void call(final String message)
{
manager.getPlayerInterface().addTextToStatusPanel(message);
}
}
);
while (!model.isReady() && !shouldTerminate)
{
manager.setLiveAIs(model.getLiveAIs());
allowHumanBasedStepStart.set(model.expectsHumanInput());
try
{
final List<AI> liveAIs = manager.liveAIs();
if (liveAIs != null && !liveAIs.isEmpty())
{
EventQueue.invokeAndWait(() ->
{
manager.getPlayerInterface().repaint();
});
}
Thread.sleep(AI_VIS_UPDATE_TIME);
}
catch (final InterruptedException | InvocationTargetException e)
{
e.printStackTrace();
}
}
if (shouldTerminate)
return;
EventQueue.invokeLater(() ->
{
manager.getPlayerInterface().repaint();
});
allowHumanBasedStepStart.set(false);
manager.setLiveAIs(null);
// If we transitioned to new instance, we need to pause
if (startInstanceTrial != context.currentInstanceContext().trial())
manager.settingsManager().setAgentsPaused(manager, true);
if (!manager.settingsManager().agentsPaused())
{
final List<AI> ais = model.getLastStepAIs();
EventQueue.invokeLater(() ->
{
for (int i = 0; i < ais.size(); ++i)
{
final AI ai = ais.get(i);
if (ai != null)
{
final String analysisReport = ai.generateAnalysisReport();
if (analysisReport != null)
manager.getPlayerInterface().addTextToAnalysisPanel(analysisReport + "\n");
}
}
});
if (!context().trial().over())
{
wantNextMoveCall.set(true);
nextMove(manager, false);
}
else
{
allowHumanBasedStepStart.set(true);
}
}
else
{
allowHumanBasedStepStart.set(true);
}
}
});
moveThread.setDaemon(true);
moveThread.start();
// Don't return until the model has at least started running (or maybe instantly completed)
while (!wantNextMoveCall.get() && moveThread != null && moveThread.isAlive() && (model.isReady() || !model.isRunning()))
{
// Don't return from call yet, keep calling thread occupied until
// model is at least properly running (or maybe already finished)
}
}
}
else
{
return false;
}
return true;
}
finally
{
if (!humanBasedStepStart && !context.model().isRunning())
{
allowHumanBasedStepStart.set(true);
}
}
}
//-------------------------------------------------------------------------
/**
* Callback to call prior to application of AI-chosen moves
*/
void preMoveApplication(final Manager manager, final Move move)
{
if (manager.settingsManager().showRepetitions())
{
final Context newContext = new Context(context);
newContext.trial().previousState().clear();
newContext.trial().previousStateWithinATurn().clear();
newContext.game().apply(newContext, move);
manager.settingsManager().setMovesAllowedWithRepetition(newContext.game().moves(newContext).moves());
}
}
//-------------------------------------------------------------------------
/**
* Handle miscellaneous stuff we need to do after applying a move
*/
public void postMoveApplication(final Manager manager, final Move move, final boolean savedMove)
{
// Store the hash of each state encountered.
if (manager.settingsManager().showRepetitions() && !manager.settingsManager().storedGameStatesForVisuals().contains(Long.valueOf(context.state().stateHash())))
manager.settingsManager().storedGameStatesForVisuals().add(Long.valueOf(context.state().stateHash()));
if (!savedMove)
{
manager.undoneMoves().clear();
if (manager.settingsNetwork().getActiveGameId() != 0)
{
String scoreString = "";
if (context.game().requiresScore())
for (int i = 1; i <= context.game().players().count(); i++)
scoreString += context.score(context.state().playerToAgent(i)) + ",";
final int moveNumber = context.currentInstanceContext().trial().numMoves() - context.currentInstanceContext().trial().numInitialPlacementMoves();
manager.databaseFunctionsPublic().sendMoveToDatabase(manager, move, context.state().mover(), scoreString, moveNumber);
manager.databaseFunctionsPublic().checkNetworkSwap(manager, move);
}
// Check if need to apply instant Pass move.
checkInstantPass(manager);
}
manager.getPlayerInterface().setTemporaryMessage("");
manager.getPlayerInterface().postMoveUpdates(move, savedMove);
}
//-------------------------------------------------------------------------
/**
* Checks if a pass move should be applied instantly, if its the only legal move and the game is stochastic.
*/
private void checkInstantPass(final Manager manager)
{
final Moves legal = context.game().moves(context);
final Move firstMove = legal.moves().get(0);
if
(
manager.aiSelected()[manager.moverToAgent()].ai() == null // Don't check instant pass if an AI is selected. Can potentially cause GUI threading issues.
&&
legal.moves().size() == 1 && firstMove.isPass() && firstMove.isForced()
&&
(!context.game().isStochasticGame() || manager.settingsManager().alwaysAutoPass())
&&
manager.settingsNetwork().getActiveGameId() == 0 // Instant pass can cause problems for remote games.
)
{
applyHumanMoveToGame(manager, firstMove);
}
}
//-------------------------------------------------------------------------
/**
* Attempts to interrupt any AI that is currently running, and returns only once there no longer is any AI thinking thread alive.
*/
public void interruptAI(final Manager manager)
{
context.model().interruptAIs();
manager.setLiveAIs(null);
allowHumanBasedStepStart.set(true);
}
//-------------------------------------------------------------------------
/**
* Runnable for per-step threads in Referee
*
* @author Dennis Soemers
*/
protected static abstract class RefereeStepRunnable implements Runnable
{
/** We can set this to true to indicate that we want to terminate, for example when loading a new game */
public boolean shouldTerminate = false;
}
/**
* Per-step thread for referee
*
* @author Dennis Soemers
*/
protected static class RefereeStepThread extends Thread
{
/** Our runnable */
public final RefereeStepRunnable runnable;
/**
* Constructor
* @param runnable
*/
public RefereeStepThread(final RefereeStepRunnable runnable)
{
super(runnable);
this.runnable = runnable;
}
}
//-------------------------------------------------------------------------
}
| 21,455 | 27.569907 | 161 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/ai/AIDetails.java
|
package manager.ai;
import java.util.ArrayList;
import java.util.List;
import org.json.JSONObject;
import manager.Manager;
import other.AI;
import utils.AIFactory;
/**
* Object for storing all GUI-relevant details about an particular player/AI.
*
* @author Matthew.Stephenson
*/
public class AIDetails
{
/** AI JSONObject */
private JSONObject object;
/** AI for controlling this player (can be Human) */
private AI aI;
/** Thinking time for this AI */
private double thinkTime;
/** Name of this AI/player */
private String name;
/** Menu Name for this AI/player (used for the player panel) */
private String menuItemName;
//-------------------------------------------------------------------------
public AIDetails(final Manager manager, final JSONObject object, final int playerId, final String menuItemName)
{
this.object = object;
if (object != null)
{
final JSONObject aiObj = object.getJSONObject("AI");
final String algName = aiObj.getString("algorithm");
if (!algName.equalsIgnoreCase("Human"))
{
AI aiFromName = AIFactory.fromJson(object);
if (manager.isWebApp() && manager.ref().context() != null && aiFromName.usesFeatures(manager.ref().context().game()))
{
final JSONObject json = new JSONObject()
.put("AI", new JSONObject()
.put("algorithm", "UCT")
);
aiFromName = AIFactory.fromJson(json);
}
setAI(aiFromName);
}
}
else
{
this.object = new JSONObject().put
(
"AI", new JSONObject().put("algorithm", "Human")
);
}
try
{
name = manager.aiSelected()[playerId].name();
}
catch (final Exception e)
{
name = "Player " + playerId;
}
try
{
thinkTime = manager.aiSelected()[playerId].thinkTime();
}
catch (final Exception e)
{
thinkTime = 1.0;
}
this.menuItemName = menuItemName;
}
//-------------------------------------------------------------------------
public String name()
{
return name;
}
public void setName(final String name)
{
this.name = name;
}
public String menuItemName()
{
return menuItemName;
}
public void setMenuItemName(final String menuItemName)
{
this.menuItemName = menuItemName;
}
public JSONObject object()
{
return object;
}
public AI ai()
{
// AI might have been set to null during game compilation, in which case it needs to be recreated.
if (aI == null && object != null)
{
final JSONObject aiObj = object.getJSONObject("AI");
final String algName = aiObj.getString("algorithm");
if (!algName.equalsIgnoreCase("Human"))
{
setAI(AIFactory.fromJson(object));
}
}
return aI;
}
public double thinkTime()
{
return thinkTime;
}
public void setThinkTime(final double thinkTime)
{
this.thinkTime = thinkTime;
}
//-------------------------------------------------------------------------
public static AIDetails getCopyOf(final Manager manager, final AIDetails oldAIDetails, final int playerId)
{
if (oldAIDetails == null)
return new AIDetails(manager, null, playerId, "Human");
final AIDetails newAIDetails = new AIDetails(manager, oldAIDetails.object(), playerId, oldAIDetails.menuItemName);
newAIDetails.setName(oldAIDetails.name());
newAIDetails.setThinkTime(oldAIDetails.thinkTime());
newAIDetails.setName(oldAIDetails.name());
return newAIDetails;
}
//-------------------------------------------------------------------------
public static List<AI> convertToAIList(final AIDetails[] details)
{
final List<AI> aiList = new ArrayList<>();
for (final AIDetails detail : details)
aiList.add(detail.ai());
return aiList;
}
public static double[] convertToThinkTimeArray(final AIDetails[] details)
{
final double[] timeArray = new double[details.length];
for (int i = 0; i < details.length; i++)
timeArray[i] = details[i].thinkTime();
return timeArray;
}
//-------------------------------------------------------------------------
public boolean equals(final AIDetails aiDetails)
{
if (!aiDetails.object.equals(object))
return false;
if (!aiDetails.name.equals(name))
return false;
if (!aiDetails.menuItemName.equals(menuItemName))
return false;
return true;
}
//-------------------------------------------------------------------------
public void setAI(final AI aI)
{
this.aI = aI;
}
//-------------------------------------------------------------------------
}
| 4,485 | 21.318408 | 121 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/ai/AIRegistry.java
|
package manager.ai;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.json.JSONObject;
import game.Game;
import other.AI;
import search.flat.FlatMonteCarlo;
import search.mcts.MCTS;
import search.minimax.AlphaBetaSearch;
import search.minimax.BRSPlus;
import utils.AIFactory;
import utils.AIFactory.AIConstructor;
import utils.RandomAI;
/**
* A registry of AIs that can be instantiated in the GUI of Ludii.
*
* @author Dennis Soemers, Eric.Piette
*/
public class AIRegistry
{
//-------------------------------------------------------------------------
/** Our registry */
protected static Map<String, AIRegistryEntry> registry = new HashMap<String, AIRegistryEntry>();
/** Rank to assign to next registered AI (used for sorting when we want a sorted list of AIs) */
protected static volatile int nextRank = 0;
static
{
// Static block to register our built-in AIs
registerAI("Human", -1, (game) -> {return false;}, null); // We have special handling for human in dropdown menus
registerAI("Ludii AI", -1, (game) -> {return true;}, null);
registerAI("Random", 1, (game) -> {return new RandomAI().supportsGame(game);}, null);
registerAI("Flat MC", 2, (game) -> {return new FlatMonteCarlo().supportsGame(game);}, null);
registerAI("UCT", 3, (game) -> {return MCTS.createUCT().supportsGame(game);}, null);
registerAI("UCT (Uncapped)", 4, (game) -> {return MCTS.createUCT().supportsGame(game);}, null);
registerAI("MC-GRAVE", 5, (game) -> {return AIFactory.createAI("MC-GRAVE").supportsGame(game);}, null);
registerAI("Progressive History", 6, (game) -> {return AIFactory.createAI("Progressive History").supportsGame(game);}, null);
registerAI("MAST", 7, (game) -> {return AIFactory.createAI("MAST").supportsGame(game);}, null);
registerAI("Biased MCTS", 8, (game) -> {return MCTS.createBiasedMCTS(0.0).supportsGame(game);}, null);
registerAI("MCTS (Biased Selection)", 9, (game) -> {return MCTS.createBiasedMCTS(1.0).supportsGame(game);}, null);
registerAI("Alpha-Beta", 10, (game) -> {return AlphaBetaSearch.createAlphaBeta().supportsGame(game);}, null);
registerAI("BRS+", 11, (game) -> {return new BRSPlus().supportsGame(game);}, null);
registerAI("MCTS (Hybrid Selection)", 12, (game) -> {return MCTS.createHybridMCTS().supportsGame(game);}, null);
registerAI("Bandit Tree Search", 13, (game) -> {return MCTS.createBanditTreeSearch().supportsGame(game);}, null);
registerAI("NST", 14, (game) -> {return AIFactory.createAI("NST").supportsGame(game);}, null);
registerAI("UCB1Tuned", 15, (game) -> {return AIFactory.createAI("UCB1Tuned").supportsGame(game);}, null);
registerAI("Progressive Bias", 16, (game) -> {return AIFactory.createAI("Progressive Bias").supportsGame(game);}, null);
registerAI("EPT", 17, (game) -> {return AIFactory.createAI("EPT").supportsGame(game);}, null);
registerAI("EPT-QB", 18, (game) -> {return AIFactory.createAI("EPT-QB").supportsGame(game);}, null);
registerAI("Score Bounded MCTS", 19, (game) -> {return AIFactory.createAI("Score Bounded MCTS").supportsGame(game);}, null);
registerAI("Heuristic Sampling", 20, (game) -> {return AIFactory.createAI("Heuristic Sampling").supportsGame(game);}, null);
registerAI("One-Ply (No Heuristic)", 21, (game) -> {return AIFactory.createAI("One-Ply (No Heuristic)").supportsGame(game);}, null);
//registerAI("Bob the Basic AI", 22, (game) -> {return true;}, null);
registerAI("UBFM", 23, (game) -> {return AIFactory.createAI("UBFM").supportsGame(game);}, null);
registerAI("Hybrid UBFM", 24, (game) -> {return AIFactory.createAI("Hybrid UBFM").supportsGame(game);}, null);
registerAI("Biased UBFM", 25, (game) -> {return AIFactory.createAI("Biased UBFM").supportsGame(game);}, null);
registerAI("Lazy UBFM", 26, (game) -> {return AIFactory.createAI("Lazy UBFM").supportsGame(game);}, null);
registerAI("From JAR", -1, (game) -> {return false;}, null); // We have special handling for From JAR in dropdown menus
}
//-------------------------------------------------------------------------
/**
* Registers a new AI. NOTE: this method does not provide a predicate to test
* whether or not any given game is supported, so we assume that ANY game is
* supported!
*
* @param label
* @param aiConstructor Functor to use for constructing AIs
* @return True if we successfully registered an AI, false if an AI with
* the same label was already registered.
*/
public static boolean registerAI(final String label, final AIConstructor aiConstructor)
{
return registerAI(label, -1, (game) -> {return true;}, aiConstructor);
}
/**
* Registers a new AI.
*
* @param label
* @param aiConstructor Functor to use for constructing AIs
* @param supportsGame Predicate to test whether or not any given game is supported.
* @return True if we successfully registered an AI, false if an AI with
* the same label was already registered.
*/
public static boolean registerAI
(
final String label, final AIConstructor aiConstructor, final SupportsGamePredicate supportsGame
)
{
return registerAI(label, -1, supportsGame, aiConstructor);
}
//-------------------------------------------------------------------------
/**
* @param game
* @return List of all agent names that are valid for given game
*/
public static List<String> generateValidAgentNames(final Game game)
{
final List<String> names = new ArrayList<String>();
for (final Entry<String, AIRegistryEntry> entry : registry.entrySet())
{
if (entry.getValue().supportsGame(game))
names.add(entry.getKey());
}
names.sort
(
new Comparator<String>()
{
@Override
public int compare(final String o1, final String o2)
{
return registry.get(o1).rank - registry.get(o2).rank;
}
}
);
return names;
}
/**
* Updates the given JSON object to properly handle registered third-party AIs
* @param json
*/
public static void processJson(final JSONObject json)
{
if (json == null || json.getJSONObject("AI") == null)
return;
final AIRegistryEntry entry = registry.get(json.getJSONObject("AI").getString("algorithm"));
if (entry != null)
{
final AIConstructor constructor = entry.aiConstructor();
if (constructor != null)
json.put("constructor", constructor);
}
}
//-------------------------------------------------------------------------
/**
* Registers a new AI
* @param label
* @param dbID
* @param supportsGame
* @param aiConstructor
* @return True if we successfully registered an AI, false if an AI with
* the same label was already registered.
*/
private static boolean registerAI
(
final String label, final int dbID,
final SupportsGamePredicate supportsGame, final AIConstructor aiConstructor
)
{
if (registry.containsKey(label))
return false;
registry.put(label, new AIRegistryEntry(label, dbID, supportsGame, aiConstructor));
return true;
}
//-------------------------------------------------------------------------
/**
* @param agentName The name of the agent.
* @return The AI object from its name.
*/
public static AI fromRegistry
(
final String agentName
)
{
final JSONObject json = new JSONObject();
final JSONObject aiJson = new JSONObject();
aiJson.put("algorithm", agentName);
json.put("AI", aiJson);
AIRegistry.processJson(json);
return AIFactory.fromJson(json);
}
//-------------------------------------------------------------------------
/**
* Interface for a predicate that tests whether or not an AI supports a given game.
*
* @author Dennis Soemers
*/
public static interface SupportsGamePredicate
{
/**
* @param game
* @return True if and only if the given game is supported.
*/
public boolean supportsGame(final Game game);
}
//-------------------------------------------------------------------------
/**
* An entry in the AI registry
*
* @author Dennis Soemers
*/
public static class AIRegistryEntry
{
/** Label of the entry */
private final String label;
/** Database ID of the AI (only built-in Ludii agents can have a database ID >= 0) */
private final int dbID;
/** Predicate to test whether or not we support a given game */
private final SupportsGamePredicate supportsGame;
/** Functor to construct AIs. If null, we'll use the AI factory to construct based on just name */
private final AIConstructor aiConstructor;
/** Used for sorting when we want sorted lists (in order of registration) */
protected final int rank;
/**
* Constructor.
*
* NOTE: intentionally protected. We want third-party users to go through the static
* registerAI() method.
*
* @param label
* @param dbID
* @param supportsGame
*/
protected AIRegistryEntry
(
final String label, final int dbID,
final SupportsGamePredicate supportsGame, final AIConstructor aiConstructor
)
{
this.label = label;
this.dbID = dbID;
this.supportsGame = supportsGame;
this.aiConstructor = aiConstructor;
this.rank = nextRank++;
}
/**
* @return The AI's label
*/
public String label()
{
return label;
}
/**
* @return Functor to use to construct AIs. If this returns null, should instead
* construct AIs just from name.
*/
public AIConstructor aiConstructor()
{
return aiConstructor;
}
/**
* @return The AI's database ID (only >= 0 for Ludii built-in AIs)
*/
public int dbID()
{
return dbID;
}
/**
* @param game
* @return True if and only if we support the given game
*/
public boolean supportsGame(final Game game)
{
return supportsGame.supportsGame(game);
}
}
//-------------------------------------------------------------------------
}
| 9,892 | 32.422297 | 134 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/ai/AIUtil.java
|
package manager.ai;
import java.awt.EventQueue;
import org.json.JSONObject;
import manager.Manager;
import other.AI;
import other.context.Context;
import other.model.SimultaneousMove;
import utils.AIUtils;
/**
* Functions for handling AI agents.
*
* @author Matthew.Stephenson
*/
public class AIUtil
{
/**
* Cycles all players backwards by one.
*/
public static void cycleAgents(final Manager manager)
{
manager.settingsManager().setAgentsPaused(manager, true);
final AIDetails player1Details = AIDetails.getCopyOf(manager, manager.aiSelected()[1], 1);
for (int i = 2; i <= manager.ref().context().game().players().count(); i++)
manager.aiSelected()[i-1] = AIDetails.getCopyOf(manager, manager.aiSelected()[i], i);
manager.aiSelected()[manager.ref().context().game().players().count()] = player1Details;
manager.settingsNetwork().backupAiPlayers(manager);
}
//-------------------------------------------------------------------------
/**
* Update the selected AI agents for the given player numbers.
*/
public static void updateSelectedAI(final Manager manager, final JSONObject inJSON, final int playerNum, final String aiMenuName)
{
String menuName = aiMenuName;
JSONObject json = inJSON;
final JSONObject aiObj = json.getJSONObject("AI");
final String algName = aiObj.getString("algorithm");
if (algName.equals("Human"))
{
// First close previous AI if it exists
if (manager.aiSelected()[playerNum].ai() != null)
manager.aiSelected()[playerNum].ai().closeAI();
manager.aiSelected()[playerNum] = new AIDetails(manager, null, playerNum, "Human");
return;
}
else if (algName.equals("From JAR"))
{
if (!aiObj.has("JAR File") || !aiObj.has("Class Name"))
{
json = manager.getPlayerInterface().getNameFromJar();
if (json == null)
return;
menuName = "From JAR";
}
}
else if (algName.equals("From JSON"))
{
if (!aiObj.has("JSON File") || !aiObj.has("Class Name"))
{
json = manager.getPlayerInterface().getNameFromJson();
if (json == null)
return;
menuName = "From JSON";
}
}
else if (algName.equals("From AI.DEF"))
{
if (!aiObj.has("AI.DEF File") || !aiObj.has("Class Name"))
{
json = manager.getPlayerInterface().getNameFromAiDef();
if (json == null)
return;
menuName = "From AI.DEF";
}
}
else
{
AIRegistry.processJson(json);
}
// First close previous AI if it exists
if (manager.aiSelected()[playerNum].ai() != null)
manager.aiSelected()[playerNum].ai().closeAI();
manager.aiSelected()[playerNum] = new AIDetails(manager, json, playerNum, menuName);
manager.settingsNetwork().backupAiPlayers(manager);
pauseAgentsIfNeeded(manager);
return;
}
//-------------------------------------------------------------------------
/**
* Pauses all agents if required.
* Should be called any time the game is restarted/loaded, or an AI is selected.
*/
public static void pauseAgentsIfNeeded(final Manager manager)
{
if (manager.settingsNetwork().getActiveGameId() != 0 && !manager.settingsNetwork().getOnlineAIAllowed())
manager.settingsManager().setAgentsPaused(manager, true);
else if (manager.aiSelected()[manager.moverToAgent()].ai() != null)
manager.settingsManager().setAgentsPaused(manager, true);
else if (manager.ref().context().model() instanceof SimultaneousMove)
manager.settingsManager().setAgentsPaused(manager, true);
else if (manager.ref().context().game().players().count() == 0)
manager.settingsManager().setAgentsPaused(manager, true);
else
manager.settingsManager().setAgentsPaused(manager, false);
}
//-------------------------------------------------------------------------
/**
* Checks if any of the currently selected AI are not supported by the current game.
* @param context
*/
public static void checkAISupported(final Manager manager, final Context context)
{
// Make sure all AIs are initialised.
for (int p = 1; p < manager.aiSelected().length; ++p)
{
if (manager.aiSelected()[p].ai() == null)
continue;
if (!manager.aiSelected()[p].ai().supportsGame(context.game()))
{
final AI oldAI = manager.aiSelected()[p].ai();
final AI newAI = AIUtils.defaultAiForGame(context.game());
final JSONObject json = new JSONObject()
.put("AI", new JSONObject()
.put("algorithm", newAI.friendlyName())
);
manager.aiSelected()[p] = new AIDetails(manager, json, p, "Ludii AI");
EventQueue.invokeLater(() ->
{
manager.getPlayerInterface().addTextToStatusPanel(oldAI.friendlyName() + " does not support this game. Switching to default AI for this game: " + newAI.friendlyName() + ".\n");
});
}
if (p <= context.game().players().count())
manager.aiSelected()[p].ai().initIfNeeded(context.game(), p);
}
manager.settingsNetwork().backupAiPlayers(manager);
}
//-------------------------------------------------------------------------
/**
* @param manager
* @return If any of the games players are being controlled by an AI.
*/
public static boolean anyAIPlayer(final Manager manager)
{
for (int i = 1; i <= manager.ref().context().game().players().count(); i++)
if (manager.aiSelected()[i].ai() != null)
return true;
return false;
}
//-------------------------------------------------------------------------
}
| 5,404 | 28.697802 | 181 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/network/DatabaseFunctionsPublic.java
|
package manager.network;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.rng.core.RandomProviderDefaultState;
import manager.Manager;
import other.context.Context;
import other.move.Move;
import other.trial.Trial;
/**
* Public class for calling database functions on the Ludii Server.
* Fake function calls. Database functionality is not available in the source code to prevent server spamming.
*
* @author Matthew.Stephenson and Dennis Soemers
*/
@SuppressWarnings("static-method")
public class DatabaseFunctionsPublic
{
//-------------------------------------------------------------------------
/** Class loader used to load private network code if available (not included in public source code repo) */
private static URLClassLoader privateNetworkCodeClassLoader = null;
// Static block to initialise classloader
static
{
final File networkPrivateBin = new File("../../LudiiPrivate/NetworkPrivate/bin");
if (networkPrivateBin.exists())
{
try
{
privateNetworkCodeClassLoader = new URLClassLoader(new URL[]{networkPrivateBin.toURI().toURL()});
}
catch (final MalformedURLException e)
{
// If this fails, that's fine, just means we don't have private code available
}
}
}
//-------------------------------------------------------------------------
/**
* @return Constructs a wrapper around the database functions.
*/
public static DatabaseFunctionsPublic construct()
{
// See if we can find private code first
final ClassLoader classLoader =
privateNetworkCodeClassLoader != null ? privateNetworkCodeClassLoader : DatabaseFunctionsPublic.class.getClassLoader();
try
{
final Class<?> privateClass = Class.forName("manager.network.privateFiles.DatabaseFunctionsPrivate", true, classLoader);
if (privateClass != null)
{
// Found private network code, use its zero-args constructor
return (DatabaseFunctionsPublic) privateClass.getConstructor().newInstance();
}
}
catch (final Exception e)
{
// Nothing to do
}
// Failed to load the private class, so we're probably working just with public source code
return new DatabaseFunctionsPublic();
}
//-------------------------------------------------------------------------
// Analysis
/**
* Gets all valid trials from the database for the provided parameters.
*/
public ArrayList<String> getTrialsFromDatabase(final String gameName, final List<String> gameOptions, final String agentName, final double thinkingTime, final int maxTurns, final int gameHash)
{
return new ArrayList<>();
}
/**
* Stores a trail in the database.
*/
public void storeTrialInDatabase(final String gameName, final List<String> gameOptions, final String agentName, final double thinkingTime, final int maxTurns, final int gameHash, final Trial trial, final RandomProviderDefaultState RNG)
{
// Do nothing.
}
/**
* Stores a website trail in the database.
*/
public void storeWebTrialInDatabase(final String gameName, final String rulesetName, final List<String> gameOptions, final int gameId, final int rulesetId, final boolean[] agents, final String username, final int gameHash, final Trial trial, final RandomProviderDefaultState RNG)
{
// Do nothing.
}
//-------------------------------------------------------------------------
// Remote
/**
* Begins repeating network actions that must be continuously performed while online.
*/
public void repeatNetworkActions(final Manager manager)
{
// Do nothing.
}
/**
* Provides an md5 encrypted hash string of a given password.
*/
public String md5(final String passwordToHash)
{
return "";
}
/**
* Refresh login flag on server, and make sure secret number up to date.
*/
public void refreshLogin(final Manager manager)
{
// Do nothing.
}
/**
* Sets the remaining time for each player.
*/
public void checkRemainingTime(final Manager manager)
{
// Do nothing.
}
/**
* Get a String representation of the remaining time for all players.
*/
public String getRemainingTime(final Manager manager)
{
return "";
}
/**
* Get a String representation of all (offline or online) players.
*/
public String GetAllPlayers()
{
return "";
}
/**
* Get a String representation of all tournaments that we have joined.
*/
public String findJoinedTournaments(final Manager manager)
{
return "";
}
/**
* Update the incoming messages chat with any new private messages.
*/
public void updateIncomingMessages(final Manager manager)
{
// Do nothing.
}
/**
* Update the last time the server was contacted.
*/
public void updateLastServerTime(final Manager manager)
{
// Do nothing.
}
/**
* Get a String representation of all private games that we have not previously joined.
*/
public String findJoinableGames(final Manager manager)
{
return "";
}
/**
* Get a String representation of all games that we have previously joined.
*/
public String findJoinedGames(final Manager manager)
{
return "";
}
/**
* Get a String representation of all games that we can spectate.
*/
public String findOtherGames(final Manager manager)
{
return "";
}
/**
* Get a String representation of all private tournaments that we have not previously joined.
*/
public String findJoinableTournaments(final Manager manager)
{
return "";
}
/**
* Get a String representation of all tournaments that we have previously joined.
*/
public String findHostedTournaments(final Manager manager)
{
return "";
}
/**
* Sends a message to the group chat for the current game.
*/
public void sendGameChatMessage(final Manager manager, final String s)
{
// Do nothing.
}
/**
* Sends a specified move to the database.
*/
public void sendMoveToDatabase(final Manager manager, final Move m, final int nextMover, final String score, final int moveNumber)
{
// Do nothing.
}
/**
* Sends the database a message to say that the game is finished
*/
public void sendGameOverDatabase(final Manager manager)
{
// Do nothing.
}
/**
* Sends the database a message to say that you have forfeit the game.
*/
public void sendForfeitToDatabase(final Manager manager)
{
// Do nothing.
}
/**
* Sends the database a message to say that you have proposed a draw.
*/
public void sendProposeDraw(final Manager manager)
{
// Do nothing.
}
/**
* Checks if each of the current game players are online or offline.
*/
public void checkOnlinePlayers(final Manager manager)
{
// Do nothing.
}
/**
* Checks if there are any outstanding moves in the database that need to be carried out.
*/
public void getMoveFromDatabase(final Manager manager)
{
// Do nothing.
}
/**
* Checks if there are any outstanding moves in the database that need to be carried out.
*/
public void checkStatesMatch(final Manager manager)
{
// Do nothing.
}
/**
* Checks if any players have forfeit or timed out.
*/
public void checkForfeitAndTimeoutAndDraw(final Manager manager)
{
// Do nothing.
}
/**
* Checks if any players have proposed a draw
*/
public void checkDrawProposed(final Manager manager)
{
// Do nothing.
}
/**
* Gets the username of each player in the game.
*/
public String[] getActiveGamePlayerNames(final Manager manager)
{
return new String[0];
}
/**
* Sends the database the current ranking of all played in the game.
*/
public void sendGameRankings(final Manager manager, final double[] rankingOriginal)
{
// Do nothing.
}
/**
* Converts an RandomProviderDefaultState object into a String representation.
*/
public String convertRNGToText(final RandomProviderDefaultState rngState)
{
return "";
}
/**
* Gets the initial RNG seed for the game from the database.
*/
public String getRNG(final Manager manager)
{
return "";
}
/**
* Gets leaderboard information from the database (leaderboard across all games is used).
*/
public String getLeaderboard()
{
return "";
}
/**
* Ping the server to check if we are still connected to it.
*/
public boolean pingServer(final String URLName)
{
return false;
}
/**
* Send result to database and update each player's statistics
*/
public void sendResultToDatabase(final Manager manager, final Context context)
{
// Do nothing.
}
/**
* Log out of the server.
*/
public void logout(final Manager manager)
{
// Do nothing.
}
/**
* Updates network player number if a swap action is made.
*/
public void checkNetworkSwap(final Manager manager, final Move move)
{
// Do nothing.
}
/**
* Location on server where remote scripts are stored.
*/
public String appFolderLocation()
{
return "";
}
/**
* Secret network number used for validating network actions.
*/
public double getSecretNetworkNumber(final Manager manager)
{
return 0.0;
}
}
| 9,056 | 22.282776 | 280 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/network/SettingsNetwork.java
|
package manager.network;
import java.awt.Rectangle;
import java.util.Arrays;
import main.Constants;
import manager.Manager;
import manager.ai.AIDetails;
/**
* Network settings.
*
* @author Matthew.Stephenson
*/
public class SettingsNetwork
{
//-------------------------------------------------------------------------
// Database function parameters
/** Thread for handling repeated network actions. */
private Thread repeatNetworkActionsThread;
/**
* Number of refreshes where the local state doesn't match that stored in the DB.
* If true for too long, a move may have been lost.
*/
private int localStateMatchesDB = 0;
//-------------------------------------------------------------------------
// Network game parameters
/** Player number in a network game, 0 if not in a network game. */
private int networkPlayerNumber = 0;
/** Number of other connected players in the current network game. */
private int numberConnectedPlayers = 0;
/** ID for the network game being played, 0 if not in a network game. */
private int activeGameId = 0;
/** ID for the tournament being played, 0 if not in a network game. */
private int tournamentId = 0;
/** Secret player network number, used for verifying player identity. */
private int secretPlayerNetworkNumber = 0;
/** If AI agents are allowed for the current network game. */
private boolean onlineAIAllowed = false;
/** Last time the server was contacted. */
private int lastServerTime = -1;
//-------------------------------------------------------------------------
// Login settings
/** ID of the user, 0 if not logged in. */
private int loginId = 0;
/** Username of the user, "" if not logged in. */
private String loginUsername = "";
/** If the user wants their username to be remembered. */
private boolean rememberDetails = false;
//-------------------------------------------------------------------------
// Remote Dialog Settings
/** Index of the remote dialog tab currently selected. */
private int tabSelected = 0;
/** Position of the remote dialog. */
private Rectangle remoteDialogPosition;
/** Backup of the AIDetails array stored in PlayerApp, for when we do online games. */
private AIDetails[] onlineBackupAiPlayers = new AIDetails[Constants.MAX_PLAYERS+1];
/** Total time remaining for each player. */
private int[] playerTimeRemaining = new int[Constants.MAX_PLAYERS];
/** If we are currently loading a network game. */
private boolean loadingNetworkGame = false;
//-------------------------------------------------------------------------
// Network player parameters
/** The active players in the current Network game. */
private boolean[] activePlayers = new boolean[Constants.MAX_PLAYERS+1];
/** The players who are online in in the current Network game. */
private boolean[] onlinePlayers = new boolean[Constants.MAX_PLAYERS+1];
/** The players who have proposed a draw this move. */
private boolean[] drawProposedPlayers = new boolean[Constants.MAX_PLAYERS+1];
//-------------------------------------------------------------------------
// Other
/** If the network should be polled for moves less often, useful when slow Internet connection. */
private boolean longerNetworkPolling = false;
/** If the network should not be automatically refreshed, useful when slow Internet connection. */
private boolean noNetworkRefresh = false;
//-------------------------------------------------------------------------
/**
* Constructor.
*/
public SettingsNetwork()
{
resetNetworkPlayers();
}
//-------------------------------------------------------------------------
/**
* Keep a backup of the AI players.
*/
public void backupAiPlayers(final Manager manager)
{
if (activeGameId == 0)
for (int i = 0; i < manager.aiSelected().length; i++)
onlineBackupAiPlayers()[i] = AIDetails.getCopyOf(manager, manager.aiSelected()[i], i);
}
//-------------------------------------------------------------------------
/**
* Restore the AI players from the saved backup.
* Used if a player joins and then leaves an online game.
*/
public void restoreAiPlayers(final Manager manager)
{
for (int i = 0; i < onlineBackupAiPlayers().length; i++)
manager.aiSelected()[i] = AIDetails.getCopyOf(manager, onlineBackupAiPlayers()[i], i);
}
//-------------------------------------------------------------------------
/**
* Reset the network players, after a game is restarted.
*/
public void resetNetworkPlayers()
{
Arrays.fill(activePlayers(), true);
Arrays.fill(onlinePlayers(), false);
Arrays.fill(drawProposedPlayers(), false);
}
//-------------------------------------------------------------------------
public int getNetworkPlayerNumber()
{
return networkPlayerNumber;
}
public void setNetworkPlayerNumber(final int networkPlayerNumber)
{
this.networkPlayerNumber = networkPlayerNumber;
}
public int getNumberConnectedPlayers()
{
return numberConnectedPlayers;
}
public void setNumberConnectedPlayers(final int numberConnectedPlayers)
{
this.numberConnectedPlayers = numberConnectedPlayers;
}
public int getLoginId()
{
return loginId;
}
public void setLoginId(final int loginId)
{
this.loginId = loginId;
}
public String loginUsername()
{
return loginUsername;
}
public void setLoginUsername(final String loginUsername)
{
this.loginUsername = loginUsername;
}
public boolean rememberDetails()
{
return rememberDetails;
}
public void setRememberDetails(final boolean rememberDetails)
{
this.rememberDetails = rememberDetails;
}
public int getActiveGameId()
{
return activeGameId;
}
public void setActiveGameId(final int activeGameId)
{
this.activeGameId = activeGameId;
}
public int tabSelected()
{
return tabSelected;
}
public void setTabSelected(final int tabSelected)
{
this.tabSelected = tabSelected;
}
public Rectangle remoteDialogPosition()
{
return remoteDialogPosition;
}
public void setRemoteDialogPosition(final Rectangle remoteDialogPosition)
{
this.remoteDialogPosition = remoteDialogPosition;
}
public int getTournamentId()
{
return tournamentId;
}
public void setTournamentId(final int tournamentId)
{
this.tournamentId = tournamentId;
}
public void setSecretNetworkNumber(final int secretNetworkNumber)
{
setSecretPlayerNetworkNumber(secretNetworkNumber);
}
public boolean getOnlineAIAllowed()
{
return onlineAIAllowed;
}
public void setOnlineAIAllowed(final boolean onlineAIAllowed)
{
this.onlineAIAllowed = onlineAIAllowed;
}
public Thread repeatNetworkActionsThread()
{
return repeatNetworkActionsThread;
}
public void setRepeatNetworkActionsThread(final Thread repeatNetworkActionsThread)
{
this.repeatNetworkActionsThread = repeatNetworkActionsThread;
}
public int localStateMatchesDB()
{
return localStateMatchesDB;
}
public void setLocalStateMatchesDB(final int localStateMatchesDB)
{
this.localStateMatchesDB = localStateMatchesDB;
}
public AIDetails[] onlineBackupAiPlayers()
{
return onlineBackupAiPlayers;
}
public void setOnlineBackupAiPlayers(final AIDetails[] onlineBackupAiPlayers)
{
this.onlineBackupAiPlayers = onlineBackupAiPlayers;
}
public int[] playerTimeRemaining()
{
return playerTimeRemaining;
}
public void setPlayerTimeRemaining(final int[] playerTimeRemaining)
{
this.playerTimeRemaining = playerTimeRemaining;
}
public boolean loadingNetworkGame()
{
return loadingNetworkGame;
}
public void setLoadingNetworkGame(final boolean loadingNetworkGame)
{
this.loadingNetworkGame = loadingNetworkGame;
}
public boolean[] activePlayers()
{
return activePlayers;
}
public void setActivePlayers(final boolean[] activePlayers)
{
this.activePlayers = activePlayers;
}
public boolean[] onlinePlayers()
{
return onlinePlayers;
}
public void setOnlinePlayers(final boolean[] onlinePlayers)
{
this.onlinePlayers = onlinePlayers;
}
public boolean[] drawProposedPlayers()
{
return drawProposedPlayers;
}
public void setDrawProposedPlayers(final boolean[] drawProposedPlayers)
{
this.drawProposedPlayers = drawProposedPlayers;
}
public boolean longerNetworkPolling()
{
return longerNetworkPolling;
}
public void setLongerNetworkPolling(final boolean longer)
{
longerNetworkPolling = longer;
}
public boolean noNetworkRefresh()
{
return noNetworkRefresh;
}
public void setNoNetworkRefresh(final boolean no)
{
noNetworkRefresh = no;
}
public int lastServerTime()
{
return lastServerTime;
}
public void setLastServerTime(final int lastServerTime)
{
this.lastServerTime = lastServerTime;
}
public int secretPlayerNetworkNumber()
{
return secretPlayerNetworkNumber;
}
public void setSecretPlayerNetworkNumber(final int secretPlayerNetworkNumber)
{
this.secretPlayerNetworkNumber = secretPlayerNetworkNumber;
}
//-------------------------------------------------------------------------
}
| 9,098 | 23.007916 | 99 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/network/local/LocalFunctions.java
|
package manager.network.local;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import game.rules.play.moves.Moves;
import manager.Manager;
import other.context.Context;
/**
* Local network functions that can be called by external agents using sockets.
* Messages are formatted as "XXXX ACTION EXTRA", where XXXX is the port number to return messages to, ACTION is the keyword for the desired task (see below), and EXTRA is any additional information.
* Example messages include:
* "5555 move 4" (make the 4th legal move)
* "5555 legal" (return all legal moves)
* "5555 player" (return the current mover)
*
* @author Matthew.Stephenson
*/
public class LocalFunctions
{
static ServerSocket serverSocket;
static Socket socket;
//-------------------------------------------------------------------------
/**
* Initialise the server socket and await messages.
*/
public static void initialiseServerSocket(final Manager manager, final int port)
{
new Thread(new Runnable()
{
@Override
public void run()
{
try
{
serverSocket = new ServerSocket(port);
while (true)
{
// Establish connection.
socket = serverSocket.accept();
final DataInputStream dis = new DataInputStream(socket.getInputStream());
// Print any messages from socket.
final String message = dis.readUTF();
System.out.println("message= " + message);
// Reply string to respond to incoming messages.
String reply = "";
// Request about a move made.
if (message.length() >= 9 && message.substring(5, 9).equals("move"))
{
reply = "move failure";
final Context context = manager.ref().context();
final Moves legal = context.game().moves(context);
for (int i = 0; i < legal.moves().size(); i++)
{
if (i == Integer.parseInt(message.substring(10).trim()))
{
manager.ref().applyHumanMoveToGame(manager, context.game().moves(context).moves().get(i));
reply = "move success";
}
}
initialiseClientSocket(Integer.parseInt(message.substring(0,4)), reply);
}
// Request about legal moves.
else if (message.length() >= 10 && message.substring(5, 10).equals("legal"))
{
final Context context = manager.ref().context();
final Moves legal = context.game().moves(context);
for (int i = 0; i < legal.moves().size(); i++)
reply += i + " - " + legal.moves().get(i).getActionsWithConsequences(context) + "\n";
initialiseClientSocket(Integer.parseInt(message.substring(0,4)), "legal\n" + reply);
}
// Request about current mover.
else if (message.length() >= 11 && message.substring(5, 11).equals("player"))
{
reply = Integer.toString(manager.ref().context().state().mover());
initialiseClientSocket(Integer.parseInt(message.substring(0,4)), "player " + reply);
}
System.out.println("Reply= " + reply);
}
}
catch(final Exception e)
{
e.printStackTrace();
try
{
serverSocket.close();
socket.close();
}
catch (final IOException e1)
{
e1.printStackTrace();
}
}
}
}).start();
}
//-------------------------------------------------------------------------
/**
* Initialise the client socket when a message needs to be sent.
*/
public static void initialiseClientSocket(final int port, final String Message)
{
new Thread(new Runnable()
{
@Override
public void run()
{
try (final Socket clientSocket = new Socket("localhost",port))
{
try(final DataOutputStream dout = new DataOutputStream(clientSocket.getOutputStream()))
{
dout.writeUTF(Message);
dout.flush();
dout.close();
clientSocket.close();
}
catch(final Exception e)
{
e.printStackTrace();
}
}
catch(final Exception e)
{
e.printStackTrace();
}
}
}).start();
}
//-------------------------------------------------------------------------
}
| 4,236 | 28.020548 | 199 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/network/local/RandomLocalAgent.java
|
package manager.network.local;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ThreadLocalRandom;
/**
* An example random agent that makes moves using the Ludii socket interface.
* Start a separate Ludii application, and select the Remote -> Initialise Server Socket menu option.
* Enter the same port number as specified below for the portNumberLudii variable.
* Now run this program.
* This agent will make a random move every time the turn number of the game being played equals the playerNumber variable below.
*
* @author Matthew.Stephenson
*/
public class RandomLocalAgent
{
// Change this based on your player number in the game.
static final int playerNumber = 2;
// Change this to the port number of the Ludii application.
static final int portNumberLudii = 4444;
// Change this to the port number used by the agent.
static final int portNumberAgent = 5555;
// Last recorded mover
static int currentPlayerNumber = 0;
// Last recorded legal moves
static String currentLegalMoves = "";
static ServerSocket serverSocket;
static Socket socket;
//-------------------------------------------------------------------------
/**
* Initialise the agent's own server socket, to receive incoming messages from the Ludii application.
* @param port
*/
public static void initialiseServerSocket(final int port)
{
new Thread(new Runnable()
{
@Override
public void run()
{
try
{
serverSocket = new ServerSocket(port);
while (true)
{
// Establish connection.
socket = serverSocket.accept();
final DataInputStream dis = new DataInputStream(socket.getInputStream());
// Print any messages from socket.
final String message = dis.readUTF();
System.out.println("message= " + message);
// Request about legal moves.
if (message.substring(0,5).equals("legal"))
{
currentLegalMoves = message.substring(6);
}
// Request about current mover.
if (message.substring(0,6).equals("player"))
{
currentPlayerNumber = Integer.parseInt(message.substring(7));
}
}
}
catch(final Exception e)
{
e.printStackTrace();
try
{
serverSocket.close();
socket.close();
}
catch (final IOException e1)
{
e1.printStackTrace();
}
}
}
}).start();
}
//-------------------------------------------------------------------------
/**
* Sends the specified message to the specified port.
* @param port
* @param Message
*/
public static void initialiseClientSocket(final int port, final String Message)
{
try (final Socket clientSocket = new Socket("localhost",port))
{
try (final DataOutputStream dout = new DataOutputStream(clientSocket.getOutputStream()); )
{
dout.writeUTF(Message);
dout.flush();
dout.close();
clientSocket.close();
}
catch(final Exception e)
{
e.printStackTrace();
}
}
catch(final Exception e)
{
e.printStackTrace();
}
}
//-------------------------------------------------------------------------
/**
* Agent will continuously request the Ludii application for information, and make moves where appropriate.
* @param args
*/
public static void main(final String args[])
{
initialiseServerSocket(portNumberAgent);
// Update agent stored information (current mover, legal moves)
final Runnable runnableUpdateValues = new Runnable()
{
@Override
public void run()
{
while (true)
{
initialiseClientSocket(portNumberLudii, "" + portNumberAgent + " player");
initialiseClientSocket(portNumberLudii, "" + portNumberAgent + " legal");
try
{
Thread.sleep(10);
}
catch (final InterruptedException e)
{
// You probably logged out and the thread was interrupted.
}
}
}
};
final Thread repeatUpdateValuesThread = new Thread(runnableUpdateValues);
repeatUpdateValuesThread.start();
// If its the agent's turn, make a random move.
final long timeInterval = 100;
final Runnable runnableMakeMove = new Runnable()
{
@Override
public void run()
{
while (true)
{
if (playerNumber == currentPlayerNumber)
{
final String[] allLegalMoves = currentLegalMoves.split("\n");
final int randomNum = ThreadLocalRandom.current().nextInt(0, allLegalMoves.length);
initialiseClientSocket(portNumberLudii, "" + portNumberAgent + " move " + randomNum);
}
try
{
Thread.sleep(timeInterval);
}
catch (final InterruptedException e)
{
// You probably logged out and the thread was interrupted.
}
}
}
};
final Thread repeatMakeMoveThread = new Thread(runnableMakeMove);
repeatMakeMoveThread.start();
}
//-------------------------------------------------------------------------
}
| 5,052 | 25.73545 | 129 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/utils/SettingsManager.java
|
package manager.utils;
import java.util.ArrayList;
import gnu.trove.map.hash.TObjectIntHashMap;
import main.Constants;
import main.collections.FastArrayList;
import main.options.UserSelections;
import manager.Manager;
import other.move.Move;
/**
* Settings used by the Manager Module.
*
* @author Matthew.Stephenson and cambolbro
*/
public final class SettingsManager
{
//-------------------------------------------------------------------------
// User settings
/** Visualize repetition moves */
private boolean showRepetitions = false;
/** Whether or not the agent(s) are paused. */
private boolean agentsPaused = true;
/** The time of a tick in simulation. */
private double tickLength = 0.1;
private boolean alwaysAutoPass = false;
private double minimumAgentThinkTime = 0.5;
//-------------------------------------------------------------------------
// Variables used for displaying repeated moves.
private ArrayList<Long> storedGameStatesForVisuals = new ArrayList<>();
private FastArrayList<Move> movesAllowedWithRepetition = new FastArrayList<>();
//-------------------------------------------------------------------------
// Variables used for multiple consequence selection.
/** List of possible consequence moves. */
private ArrayList<Move> possibleConsequenceMoves = new ArrayList<>();
//-------------------------------------------------------------------------
// Variables used for turn limits.
private TObjectIntHashMap<String> turnLimits = new TObjectIntHashMap<String>();
//-------------------------------------------------------------------------
/**
* User selections for options and rulesets within a game.
* When compiling a game, pass in a "dirty" copy of this object if you
* want the settings to be set to the game's defaults, otherwise the
* game will be compiled with the settings specified here.
*/
private final UserSelections userSelections = new UserSelections(new ArrayList<String>());
//-------------------------------------------------------------------------
// Getter and setters
public boolean showRepetitions()
{
return showRepetitions;
}
public void setShowRepetitions(final boolean show)
{
showRepetitions = show;
}
public double tickLength()
{
return tickLength;
}
public void setTickLength(final double length)
{
tickLength = length;
}
public ArrayList<Long> storedGameStatesForVisuals()
{
return storedGameStatesForVisuals;
}
public void setStoredGameStatesForVisuals(final ArrayList<Long> stored)
{
storedGameStatesForVisuals = stored;
}
public FastArrayList<Move> movesAllowedWithRepetition()
{
return movesAllowedWithRepetition;
}
public void setMovesAllowedWithRepetition(final FastArrayList<Move> moves)
{
movesAllowedWithRepetition = moves;
}
public ArrayList<Move> possibleConsequenceMoves()
{
return possibleConsequenceMoves;
}
public void setPossibleConsequenceMoves(final ArrayList<Move> possible)
{
possibleConsequenceMoves = possible;
}
public int turnLimit(final String gameName)
{
if (turnLimits.contains(gameName))
return turnLimits.get(gameName);
return Constants.DEFAULT_TURN_LIMIT;
}
public void setTurnLimit(final String gameName, final int turnLimit)
{
turnLimits.put(gameName, turnLimit);
}
public TObjectIntHashMap<String> turnLimits()
{
return turnLimits;
}
public void setTurnLimits(final TObjectIntHashMap<String> turnLimits)
{
this.turnLimits = turnLimits;
}
public boolean agentsPaused()
{
return agentsPaused;
}
public void setAgentsPaused(final Manager manager, final boolean paused)
{
agentsPaused = paused;
if (agentsPaused)
manager.ref().interruptAI(manager);
}
public UserSelections userSelections()
{
return userSelections;
}
public boolean alwaysAutoPass()
{
return alwaysAutoPass;
}
public void setAlwaysAutoPass(final boolean alwaysAutoPass)
{
this.alwaysAutoPass = alwaysAutoPass;
}
public double minimumAgentThinkTime()
{
return minimumAgentThinkTime;
}
public void setMinimumAgentThinkTime(double minimumAgentThinkTime)
{
this.minimumAgentThinkTime = minimumAgentThinkTime;
}
}
| 4,188 | 22.533708 | 91 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/utils/game_logs/GameLogs.java
|
package manager.utils.game_logs;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.rng.core.RandomProviderDefaultState;
import game.Game;
import game.equipment.container.Container;
import other.state.State;
import other.state.container.ContainerState;
import other.trial.Trial;
/**
* A collection of one or more game trials which can be serialized and
* deserialized.
*
* @author Dennis Soemers
*/
public class GameLogs
{
/** */
private final String gameName;
/** */
private final Game game;
/** */
private final List<MatchRecord> matchRecords = new ArrayList<MatchRecord>();
//-------------------------------------------------------------------------
public GameLogs(final Game game)
{
gameName = game.name();
this.game = game;
}
//-------------------------------------------------------------------------
public void addMatchRecord(final MatchRecord matchRecord)
{
matchRecords.add(matchRecord);
}
public List<MatchRecord> matchRecords()
{
return matchRecords;
}
public Game game()
{
return game;
}
//-------------------------------------------------------------------------
public static GameLogs fromFile(final File file, final Game game)
{
GameLogs gameLogs = null;
try (ObjectInputStream reader = new ObjectInputStream(
new BufferedInputStream(new FileInputStream(file))))
{
final String gameName = reader.readUTF();
//final Game game = PlayerCli.getGameInstance(gameName, nbRow, nbCol);
gameLogs = new GameLogs(game);
while (reader.available() > 0)
{
final int numRngStateBytes = reader.readInt();
final byte[] rngStateBytes = new byte[numRngStateBytes];
final int numBytesRead = reader.read(rngStateBytes);
if (numBytesRead != numRngStateBytes)
{
System.err.println
(
"Warning: GameLogs.fromFile() expected " + numRngStateBytes +
" bytes, but only read " + numBytesRead + " bytes!"
);
}
final RandomProviderDefaultState rngState = new RandomProviderDefaultState(rngStateBytes);
//System.out.println("loaded state = " + Arrays.toString(rngState.getState()));
final Trial trial = (Trial) reader.readObject();
final List<State> states = trial.auxilTrialData().stateHistory();
// fix reference to container for all ItemStates
if (states != null)
{
for (final State state : states)
{
final ContainerState[] itemStates = state.containerStates();
for (final ContainerState itemState : itemStates)
{
if (itemState != null)
{
final String containerName = itemState.nameFromFile();
for (final Container container : game.equipment().containers())
{
if (container != null && container.name().equals(containerName))
{
itemState.setContainer(container);
break;
}
}
}
}
}
}
gameLogs.addMatchRecord(new MatchRecord(trial, rngState, gameName));
}
}
catch (final IOException | ClassNotFoundException e)
{
e.printStackTrace();
}
//System.out.println(gameLogs.matchRecords.get(0).trial.actions());
return gameLogs;
}
public String getGameName()
{
return gameName;
}
//-------------------------------------------------------------------------
}
| 3,513 | 23.068493 | 94 |
java
|
Ludii
|
Ludii-master/Manager/src/manager/utils/game_logs/MatchRecord.java
|
package manager.utils.game_logs;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.apache.commons.rng.core.RandomProviderDefaultState;
import game.Game;
import gnu.trove.list.array.TIntArrayList;
import main.Status;
import main.Status.EndType;
import other.move.Move;
import other.trial.Trial;
/**
* A record of a single played Match (to be serialised/deserialised, typically as a collection
* in GameLogs)
*
* @author Dennis Soemers
*/
public class MatchRecord implements Serializable
{
/** */
private static final long serialVersionUID = 1L;
//-------------------------------------------------------------------------
/** */
private final Trial trial;
/** */
private final RandomProviderDefaultState rngState;
//-------------------------------------------------------------------------
/**
* Constructor
* @param trial
* @param rngState
* @param loadedGameName
*/
public MatchRecord
(
final Trial trial,
final RandomProviderDefaultState rngState,
final String loadedGameName
)
{
this.trial = trial;
this.rngState = rngState;
}
//-------------------------------------------------------------------------
/**
* @return Reference to the current trial.
*/
public Trial trial()
{
return trial;
}
/**
* @return RNG state.
*/
public RandomProviderDefaultState rngState()
{
return rngState;
}
//-------------------------------------------------------------------------
/**
* Loads a MatchRecord from a text file
* @param file
* @param game
* @return The match record.
* @throws IOException
* @throws FileNotFoundException
*/
public static MatchRecord loadMatchRecordFromTextFile
(
final File file,
final Game game
) throws FileNotFoundException, IOException
{
try (final InputStreamReader reader = new InputStreamReader(new FileInputStream(file), "UTF-8"))
{
return loadMatchRecordFromInputStream(reader, game);
}
}
/**
* Loads a MatchRecord from a text file
* @param inputStreamReader
* @param game
* @return The match record.
* @throws IOException
* @throws FileNotFoundException
*/
public static MatchRecord loadMatchRecordFromInputStream
(
final InputStreamReader inputStreamReader,
final Game game
) throws FileNotFoundException, IOException
{
try (final BufferedReader reader = new BufferedReader(inputStreamReader))
{
final String gameNameLine = reader.readLine();
final String loadedGameName = gameNameLine.substring("game=".length());
String nextLine = reader.readLine();
while (true)
{
if (nextLine == null)
break;
if (nextLine.startsWith("RNG internal state="))
break;
if (nextLine.startsWith("NEW LEGAL MOVES LIST"))
break;
if (nextLine.startsWith("winner="))
break;
if (nextLine.startsWith("rankings="))
break;
//if (!nextLine.startsWith("START GAME OPTIONS") && !nextLine.startsWith("END GAME OPTIONS"))
// Do nothing
nextLine = reader.readLine();
}
if (!nextLine.startsWith("RNG internal state="))
{
System.err.println("ERROR: MatchRecord::loadMatchRecordFromTextFile expected to read RNG internal state!");
return null;
}
final String rngInternalStateLine = nextLine;
final String[] byteStrings = rngInternalStateLine.substring("RNG internal state=".length()).split(Pattern.quote(","));
final byte[] bytes = new byte[byteStrings.length];
for (int i = 0; i < byteStrings.length; ++i)
bytes[i] = Byte.parseByte(byteStrings[i]);
final RandomProviderDefaultState rngState = new RandomProviderDefaultState(bytes);
final Trial trial = new Trial(game);
// now we expect to be reading played Moves
nextLine = reader.readLine();
while (true)
{
if (nextLine == null)
break;
if (!nextLine.startsWith("Move="))
break;
final Move move = new Move(nextLine.substring("Move=".length()));
trial.addMove(move);
nextLine = reader.readLine();
}
// now we expect to be reading sizes of histories of legal moves lists (if they were stored)
final TIntArrayList legalMovesHistorySizes = new TIntArrayList();
while (true)
{
if (nextLine == null)
break;
if (nextLine.startsWith("NEW LEGAL MOVES LIST"))
break;
if (nextLine.startsWith("winner="))
break;
if (nextLine.startsWith("rankings="))
break;
if (nextLine.startsWith("numInitialPlacementMoves="))
break;
if (nextLine.startsWith("LEGAL MOVES LIST SIZE = "))
legalMovesHistorySizes.add(Integer.parseInt(nextLine.substring("LEGAL MOVES LIST SIZE = ".length())));
nextLine = reader.readLine();
}
// now we expect to be reading sequences of legal moves (if they were stored)
final List<List<Move>> legalMovesHistory = new ArrayList<List<Move>>();
while (true)
{
if (nextLine == null)
break;
if (nextLine.startsWith("winner="))
break;
if (nextLine.startsWith("rankings="))
break;
if (nextLine.startsWith("numInitialPlacementMoves="))
break;
if (nextLine.equals("NEW LEGAL MOVES LIST"))
legalMovesHistory.add(new ArrayList<Move>());
else if (!nextLine.equals("END LEGAL MOVES LIST"))
legalMovesHistory.get(legalMovesHistory.size() - 1).add(new Move(nextLine));
nextLine = reader.readLine();
}
if (!legalMovesHistory.isEmpty())
{
trial.storeLegalMovesHistory();
trial.setLegalMovesHistory(legalMovesHistory);
}
if (!legalMovesHistorySizes.isEmpty())
{
trial.storeLegalMovesHistorySizes();
trial.setLegalMovesHistorySizes(legalMovesHistorySizes);
}
int winner = -99; // Not 100% sure that any of the nice constants are good enough, maybe used for losers in single-player games or something?
EndType endType = EndType.Unknown;
int numInitialPlacementMoves = 0;
if (nextLine != null && nextLine.startsWith("numInitialPlacementMoves="))
{
numInitialPlacementMoves = Integer.parseInt(nextLine.substring("numInitialPlacementMoves=".length()));
nextLine = reader.readLine();
}
if (nextLine != null && nextLine.startsWith("winner="))
{
winner = Integer.parseInt(nextLine.substring("winner=".length()));
nextLine = reader.readLine();
}
if (nextLine != null && nextLine.startsWith("endtype="))
{
endType = EndType.valueOf(nextLine.substring("endtype=".length()));
nextLine = reader.readLine();
}
trial.setNumInitialPlacementMoves(numInitialPlacementMoves);
if (winner > -99)
trial.setStatus(new Status(winner, endType));
if (nextLine != null && nextLine.startsWith("rankings="))
{
final String[] rankingStrings = nextLine.substring("rankings=".length()).split(Pattern.quote(","));
for (int i = 0; i < rankingStrings.length; ++i)
{
trial.ranking()[i] = Double.parseDouble(rankingStrings[i]);
}
}
return new MatchRecord(trial, rngState, loadedGameName);
}
}
//-------------------------------------------------------------------------
}
| 7,411 | 25.007018 | 144 |
java
|
Ludii
|
Ludii-master/Manager/src/tournament/Tournament.java
|
package tournament;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.json.JSONArray;
import org.json.JSONObject;
import game.Game;
import manager.Manager;
import manager.ai.AIUtil;
/**
* A Ludii Tournament
*
* @author Dennis Soemers and Matthew Stephenson and cambolbro
*/
public class Tournament
{
/** List of games we wish to play in tournament */
private final List<String> gamesToPlay;
/** List of agents to participate in tournament */
private final List<Object> agentsToPlay;
/** Results of tournament */
private final List<String[]> results;
private List<int[]> matchUps;
private int matchUpIndex;
private int[] matchUp;
//-------------------------------------------------------------------------
/**
* Constructor from JSON
* @param json
*/
public Tournament(final JSONObject json)
{
final JSONArray listGames = json.getJSONArray("GAMES");
gamesToPlay = new ArrayList<>(listGames.length());
System.out.println("Tournament games:");
for (final Object obj : listGames)
{
final String game = (String) obj;
gamesToPlay.add(game);
System.out.println(game);
}
final JSONArray listAgents = json.getJSONArray("AGENTS");
agentsToPlay = new ArrayList<>(listAgents.length());
System.out.println("Tournament agents:");
for (final Object obj : listAgents)
{
agentsToPlay.add(obj);
System.out.println(obj);
}
results = new ArrayList<>();
}
//-------------------------------------------------------------------------
/**
* Sets up the tournament for a (new) start
*/
public void setupTournament()
{
// reset the global tournament variables
results.clear();
final int totalNumberPlayers = agentsToPlay.size();
final List<int[]> matchUpsFlipped = generate(totalNumberPlayers, 2);
matchUps = generate(totalNumberPlayers, 2);
for (int j = 0; j < matchUps.size(); j++)
{
for (int i = 0; i < matchUps.get(j).length / 2; i++)
{
final int temp = matchUps.get(j)[i];
matchUps.get(j)[i] = matchUps.get(j)[matchUps.get(j).length - i - 1];
matchUps.get(j)[matchUps.get(j).length - i - 1] = temp;
}
}
matchUps.addAll(matchUpsFlipped);
matchUpIndex = 0;
}
/**
* Run the next game for the tournament
*/
public void startNextTournamentGame(final Manager manager)
{
if (gamesToPlay.size() > 0 && matchUps.size() > 0)
{
matchUp = matchUps.get(matchUpIndex);
for (int i = 0; i < matchUp.length; i++)
{
final Object agent = agentsToPlay.get(matchUp[i]);
final JSONObject json;
if (agent instanceof JSONObject)
json = (JSONObject) agent;
else
json = new JSONObject().put("AI", new JSONObject().put("algorithm", agent));
AIUtil.updateSelectedAI(manager, json, i + 1, json.getJSONObject("AI").getString("algorithm"));
}
final List<String> gameAndOptions = Arrays.asList(gamesToPlay.get(0).split("-"));
if (gameAndOptions.size() > 1)
{
System.out.println(gameAndOptions.get(1));
manager.getPlayerInterface().loadGameFromName(gameAndOptions.get(0).trim(), gameAndOptions.subList(1, gameAndOptions.size()), false);
}
else
{
manager.getPlayerInterface().loadGameFromName(gameAndOptions.get(0).trim(), new ArrayList<String>(), false);
}
matchUpIndex++;
if (matchUpIndex >= matchUps.size())
{
matchUpIndex = 0;
gamesToPlay.remove(0);
}
manager.settingsManager().setAgentsPaused(manager, false);
manager.ref().nextMove(manager, false);
}
else
{
// The tournament is over, show the results
System.out.println("FINAL RESULTS SHORT");
// String finalResultsToSend = "FINAL RESULTS SHORT";
for (int i = 0; i < results.size(); i++)
{
final String result = Arrays.toString(results.get(i));
System.out.println(result);
// finalResultsToSend += result;
}
System.out.println("\nFINAL RESULTS LONG");
// finalResultsToSend += "FINAL RESULTS LONG";
for (int i = 0; i < results.size(); i++)
{
final String gameData = "GAME(" + (i + 1) + ") " + results.get(i)[0];
System.out.println(gameData);
// finalResultsToSend += gameData;
try
{
for (int j = 0; j < results.get(i)[1].length(); j++)
{
final String result = "Player "
+ (Integer.parseInt(results.get(i)[1].split(",")[j].replace("[", "")
.replace("]", "").trim()) + 1)
+ " : " + results.get(i)[j + 2];
System.out.println(result);
// finalResultsToSend += result;
}
}
catch (final Exception e)
{
// just skip the players that don't have scores
}
}
}
}
/**
* Storse the results obtained in a single match
*
* @param game
* @param ranking
*/
public void storeResults(final Game game, final double[] ranking)
{
final String[] result = new String[10];
try
{
result[0] = game.name();
result[1] = Arrays.toString(matchUp);
result[2] = Double.toString(ranking[1]);
result[3] = Double.toString(ranking[2]);
result[4] = Double.toString(ranking[3]);
result[5] = Double.toString(ranking[4]);
result[6] = Double.toString(ranking[5]);
result[7] = Double.toString(ranking[6]);
result[8] = Double.toString(ranking[7]);
result[9] = Double.toString(ranking[8]);
}
catch (final Exception E)
{
// player number requested probably doesn't exist, carry on as normal
}
results.add(result);
}
/**
* Called when the tournament is being aborted / ended
*/
public void endTournament()
{
// Do nothing (for now)
}
//-------------------------------------------------------------------------
/**
* generates all nCr combinations (all round robin tournament combinations)
*/
private static List<int[]> generate(final int n, final int r)
{
final List<int[]> combinations = new ArrayList<>();
final int[] combination = new int[r];
// initialize with lowest lexicographic combination
for (int i = 0; i < r; i++)
{
combination[i] = i;
}
while (combination[r - 1] < n)
{
combinations.add(combination.clone());
// generate next combination in lexicographic order
int t = r - 1;
while (t != 0 && combination[t] == n - r + t)
{
t--;
}
combination[t]++;
for (int i = t + 1; i < r; i++)
{
combination[i] = combination[i - 1] + 1;
}
}
return combinations;
}
}
| 6,317 | 23.874016 | 137 |
java
|
Ludii
|
Ludii-master/Manager/src/tournament/TournamentUtil.java
|
package tournament;
import java.awt.EventQueue;
import manager.Manager;
import other.context.Context;
/**
* Ludii Tournament util functions
*
* @author Dennis Soemers and Matthew Stephenson
*/
public class TournamentUtil
{
/**
* If Tournament is running then need to save the results of this game.
*/
public static void saveTournamentResults(final Manager manager, final Context context)
{
if (manager.tournament() != null)
{
System.out.println("SAVING RESULTS");
manager.tournament().storeResults(context.game(), context.trial().ranking());
new java.util.Timer().schedule(
new java.util.TimerTask()
{
@Override
public void run()
{
EventQueue.invokeLater(() ->
{
System.out.println("LOADING NEXT GAME");
manager.tournament().startNextTournamentGame(manager);
});
}
},
5000L
);
}
}
//-------------------------------------------------------------------------
}
| 1,063 | 22.130435 | 87 |
java
|
Ludii
|
Ludii-master/Mining/src/agentPrediction/external/AgentPredictionExternal.java
|
package agentPrediction.external;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import game.Game;
import manager.ai.AIRegistry;
import metrics.Evaluation;
import other.concept.Concept;
import other.concept.ConceptComputationType;
import other.concept.ConceptDataType;
import utils.AIUtils;
import utils.concepts.ComputePlayoutConcepts;
/**
* Predict the best agent/heuristic using external Python models.
*
* Models are produced by the "generate_agent_heuristic_prediction_models()" function in the Sklearn "Main.py" file.
*
* @author Matthew.Stephenson
*/
public class AgentPredictionExternal
{
/**
* Predict the best agent/heuristic using external Python models.
* @param game
* @param modelFilePath
* @param classificationModel
* @param heuristics
* @param compilationOnly
*/
public static Map<String,Double> predictBestAgent(final Game game, final String modelFilePath, final boolean classificationModel, final boolean heuristics, final boolean compilationOnly)
{
final long startTime = System.currentTimeMillis();
if (!compilationOnly)
ComputePlayoutConcepts.updateGame(game, new Evaluation(), 10, -1, 1, "Random", true);
else
ComputePlayoutConcepts.updateGame(game, new Evaluation(), 0, -1, 1, "Random", true); // Still need to run this with zero trials to get compilation concepts
final double ms = (System.currentTimeMillis() - startTime);
System.out.println("Playouts computation done in " + ms + " ms.");
List<String> allModelNames = AIRegistry.generateValidAgentNames(game);
if (heuristics)
allModelNames = Arrays.asList(AIUtils.allHeuristicNames());
return AgentPredictionExternal.predictBestAgentName(game, allModelNames, modelFilePath, classificationModel, compilationOnly);
}
//-------------------------------------------------------------------------
/**
* @return Name of the best predicted agent from our pre-trained set of models.
*/
public static Map<String,Double> predictBestAgentName(final Game game, final List<String> allValidLabelNames, final String modelFilePath, final boolean classificationModel, final boolean compilationOnly)
{
final Map<String, Double> agentPredictions = new HashMap<>();
String sInput = null;
String sError = null;
try
{
final String conceptNameString = "RulesetName," + conceptNameString(compilationOnly);
final String conceptValueString = "UNUSED," + conceptValueString(game, compilationOnly);
// Classification prediction, just the agent name or probability for each.
if (classificationModel)
{
final String arg1 = modelFilePath;
final String arg2 = "Classification";
final String arg3 = conceptNameString;
final String arg4 = conceptValueString;
final Process p = Runtime.getRuntime().exec("python3 ../../LudiiPrivate/DataMiningScripts/Sklearn/External/GetBestPredictedAgent.py " + arg1 + " " + arg2 + " " + arg3 + " " + arg4);
// Read file output
final BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream()));
while ((sInput = stdInput.readLine()) != null)
{
System.out.println(sInput);
if (sInput.contains("PREDICTION"))
{
// Check if returning probabilities for each class.
try
{
final String[] classNamesAndProbas = sInput.split("=")[1].split("_:_");
final String[] classNames = classNamesAndProbas[0].split("_;_");
for (int i = 0; i < classNames.length; i++)
classNames[i] = classNames[i];
final String[] valueStrings = classNamesAndProbas[1].split("_;_");
final Double[] values = new Double[valueStrings.length];
for (int i = 0; i < valueStrings.length; i++)
values[i] = Double.valueOf(valueStrings[i]);
if (classNames.length != values.length)
System.out.println("ERROR! Class Names and Values should be the same length.");
for (int i = 0; i < classNames.length; i++)
{
agentPredictions.put(classNames[i], values[i]);
}
return agentPredictions;
}
catch (final Exception e)
{
e.printStackTrace();
}
}
}
// Read any errors.
final BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream()));
while ((sError = stdError.readLine()) != null)
{
System.out.println("Python Error\n");
System.out.println(sError);
}
}
// Regression prediction, get the predicted value for each valid agent.
else
{
// Record the predicted value for each agent.
for (final String agentName : allValidLabelNames)
{
final String arg1 = modelFilePath;
final String arg2 = agentName.replaceAll(" ", "_");
final String arg3 = conceptNameString;
final String arg4 = conceptValueString;
final Process p = Runtime.getRuntime().exec("python3 ../../LudiiPrivate/DataMiningScripts/Sklearn/External/GetBestPredictedAgent.py " + arg1 + " " + arg2 + " " + arg3 + " " + arg4);
// Read file output
final BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream()));
System.out.println("Predicting for " + agentName);
while ((sInput = stdInput.readLine()) != null)
{
System.out.println(sInput);
if (sInput.contains("PREDICTION"))
{
final Double predictedValue = Double.valueOf(sInput.split("=")[1]);
agentPredictions.put(agentName, predictedValue);
}
}
// Read any errors.
final BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream()));
while ((sError = stdError.readLine()) != null)
{
System.out.println("Python Error\n");
System.out.println(sError);
}
}
return agentPredictions;
}
}
catch (final IOException e)
{
e.printStackTrace();
}
return agentPredictions;
}
//-------------------------------------------------------------------------
public static Map<String, Map<String,Double>> predictPortfolioParameters(final Game game)
{
final Map<String, Map<String,Double>> portfolioParameterPredictions = new HashMap<>();
final String[] portfolioParameters = {"Heuristics", "Agents", "Selections", "Explorations", "Playouts", "Backpropagations"};
ComputePlayoutConcepts.updateGame(game, new Evaluation(), 0, -1, 1, "Random", true); // Still need to run this with zero trials to get compilation concepts
for (final String param : portfolioParameters)
{
final Map<String,Double> paramPredictions = new HashMap<>();
String sInput = null;
String sError = null;
try
{
final String conceptNameString = "RulesetName," + conceptNameString(true);
final String conceptValueString = "UNUSED," + conceptValueString(game, true);
final String arg1 = "RandomForestClassifier-Classification-" + param + "-Portfolio";
final String arg2 = "Classification";
final String arg3 = conceptNameString;
final String arg4 = conceptValueString;
final Process p = Runtime.getRuntime().exec("python3 ../../LudiiPrivate/DataMiningScripts/Sklearn/External/GetBestPredictedAgent.py " + arg1 + " " + arg2 + " " + arg3 + " " + arg4);
// Read file output
final BufferedReader stdInput = new BufferedReader(new InputStreamReader(p.getInputStream()));
while ((sInput = stdInput.readLine()) != null)
{
System.out.println(sInput);
if (sInput.contains("PREDICTION"))
{
// Check if returning probabilities for each class.
try
{
final String[] classNamesAndProbas = sInput.split("=")[1].split("_:_");
final String[] classNames = classNamesAndProbas[0].split("_;_");
for (int i = 0; i < classNames.length; i++)
classNames[i] = classNames[i];
final String[] valueStrings = classNamesAndProbas[1].split("_;_");
final Double[] values = new Double[valueStrings.length];
for (int i = 0; i < valueStrings.length; i++)
values[i] = Double.valueOf(valueStrings[i]);
if (classNames.length != values.length)
System.out.println("ERROR! Class Names and Values should be the same length.");
for (int i = 0; i < classNames.length; i++)
{
paramPredictions.put(classNames[i], values[i]);
}
continue;
}
catch (final Exception e)
{
e.printStackTrace();
}
}
}
// Read any errors.
final BufferedReader stdError = new BufferedReader(new InputStreamReader(p.getErrorStream()));
while ((sError = stdError.readLine()) != null)
{
System.out.println("Python Error\n");
System.out.println(sError);
}
}
catch (final IOException e)
{
e.printStackTrace();
}
portfolioParameterPredictions.put(param, paramPredictions);
}
return portfolioParameterPredictions;
}
//-------------------------------------------------------------------------
/**
* @return The concepts as a string with comma between them.
*/
public static String conceptNameString(final boolean compilationOnly)
{
final Concept[] concepts = compilationOnly ? Concept.values() : Concept.portfolioConcepts();
final StringBuffer sb = new StringBuffer();
for (final Concept concept: concepts)
if (!compilationOnly || concept.computationType().equals(ConceptComputationType.Compilation))
sb.append(concept.name()+",");
sb.deleteCharAt(sb.length()-1);
return sb.toString();
}
//-------------------------------------------------------------------------
/**
* @param game The game compiled.
* @return The concepts as boolean values with comma between them.
*/
public static String conceptValueString(final Game game, final boolean compilationOnly)
{
final Concept[] concepts = compilationOnly ? Concept.values() : Concept.portfolioConcepts();
final StringBuffer sb = new StringBuffer();
for (final Concept concept: concepts)
if (!compilationOnly || concept.computationType().equals(ConceptComputationType.Compilation))
if (concept.dataType().equals(ConceptDataType.BooleanData))
sb.append((game.booleanConcepts().get(concept.id()) ? "1" : "0")).append(",");
else
sb.append((game.nonBooleanConcepts().get(Integer.valueOf(concept.id())))).append(",");
sb.deleteCharAt(sb.length()-1);
return sb.toString();
}
//-------------------------------------------------------------------------
/**
* @param modelName should be the name of the model to use (same as from GUI), e.g. "BayesianRidge"
* @param useClassifier
* @param useHeuristics
* @param useCompilationOnly
*/
public static String getModelPath(final String modelName, final boolean useClassifier, final boolean useHeuristics, final boolean useCompilationOnly)
{
String modelFilePath = modelName;
if (useClassifier)
modelFilePath += "-Classification";
else
modelFilePath += "-Regression";
if (useHeuristics)
modelFilePath += "-Heuristics";
else
modelFilePath += "-Agents";
if (useCompilationOnly)
modelFilePath += "-True";
else
modelFilePath += "-False";
return modelFilePath;
}
//-------------------------------------------------------------------------
// public static void updateAgent()
// {
// if (!heuristics)
// {
// if (playerIndexToUpdate > 0)
// {
// final JSONObject json = new JSONObject().put("AI",
// new JSONObject()
// .put("algorithm", bestPredictedAgentName)
// );
//
// AIUtil.updateSelectedAI(manager, json, playerIndexToUpdate, bestPredictedAgentName);
// }
// }
// else
// {
// if (manager.aiSelected()[playerIndexToUpdate].ai() != null)
// {
// final Heuristics heuristic = AIUtils.convertStringtoHeuristic(bestPredictedAgentName);
// manager.aiSelected()[playerIndexToUpdate].ai().setHeuristics(heuristic);
// manager.aiSelected()[playerIndexToUpdate].ai().initAI(manager.ref().context().game(), playerIndexToUpdate);
// }
// }
// }
//-------------------------------------------------------------------------
}
| 13,513 | 38.171014 | 204 |
java
|
Ludii
|
Ludii-master/Mining/src/agentPrediction/external/MetricPredictionExternal.java
|
package agentPrediction.external;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import game.Game;
import metrics.Evaluation;
import utils.concepts.ComputePlayoutConcepts;
public class MetricPredictionExternal
{
/**
* Predict the values for each metric using external Python models.
* @param game
* @param modelFilePath
* @param compilationOnly
*/
public static Map<String,Double> predictMetrics(final Game game, final String modelFilePath, final boolean compilationOnly)
{
final long startTime = System.currentTimeMillis();
if (!compilationOnly)
ComputePlayoutConcepts.updateGame(game, new Evaluation(), 10, -1, 1, "Random", true);
else
ComputePlayoutConcepts.updateGame(game, new Evaluation(), 0, -1, 1, "Random", true); // Still need to run this with zero trials to get compilation concepts
final double ms = (System.currentTimeMillis() - startTime);
System.out.println("Playouts computation done in " + ms + " ms.");
final List<String> allMetricNames = new ArrayList<>();
final File folder = new File("../../LudiiPrivate/DataMiningScripts/Sklearn/res/trainedModels/" + modelFilePath);
final File[] listOfFiles = folder.listFiles();
for (final File file : listOfFiles)
allMetricNames.add(file.getName());
return AgentPredictionExternal.predictBestAgentName(game, allMetricNames, modelFilePath, false, compilationOnly);
}
//-------------------------------------------------------------------------
}
| 1,512 | 32.622222 | 158 |
java
|
Ludii
|
Ludii-master/Mining/src/agentPrediction/internal/AgentPredictionInternal.java
|
package agentPrediction.internal;
import java.util.ArrayList;
import java.util.List;
import agentPrediction.internal.models.BaseModel;
import gnu.trove.list.array.TIntArrayList;
import manager.Manager;
import other.concept.Concept;
public class AgentPredictionInternal
{
//-------------------------------------------------------------------------
/**
* Predicts the best AI, from a given prediction model.
*/
public static void predictAI(final Manager manager, final BaseModel predictionModel)
{
manager.getPlayerInterface().selectAnalysisTab();
final String[] agentStrings = {"AlphaBeta", "MC-GRAVE", "Random", "UCT"};
// Record all the concept Names and Values
final List<String> flags = new ArrayList<String>();
final TIntArrayList flagsValues = new TIntArrayList();
for (final Concept concept : Concept.values())
{
flags.add(concept.name());
flagsValues.add(concept.id());
}
// Calculate the predicted score for each agent.
final double[] agentPredictions = predictionModel.predictAI(manager, flags, flagsValues, agentStrings);
// Give best agent prediction.
double bestAgentScore = -999999999;
String bestAgentName = "None";
for (int agentIndex = 0; agentIndex < agentStrings.length; agentIndex++)
{
if (agentPredictions[agentIndex] > bestAgentScore)
{
bestAgentScore = agentPredictions[agentIndex];
bestAgentName = agentStrings[agentIndex];
}
manager.getPlayerInterface().addTextToAnalysisPanel("Predicted win-rate for " + agentStrings[agentIndex] + ": " + agentPredictions[agentIndex] + "\n");
}
manager.getPlayerInterface().addTextToAnalysisPanel("Best predicted agent is " + bestAgentName + "\n");
manager.getPlayerInterface().addTextToAnalysisPanel("//-------------------------------------------------------------------------\n");
}
//-------------------------------------------------------------------------
}
| 1,916 | 33.232143 | 154 |
java
|
Ludii
|
Ludii-master/Mining/src/agentPrediction/internal/models/BaseModel.java
|
package agentPrediction.internal.models;
import java.util.List;
import gnu.trove.list.array.TIntArrayList;
import manager.Manager;
public interface BaseModel
{
/** The name of the model used, must match up with the filepath to the stored model. */
String modelName();
/** Returns the predicted win-rate for each agent in agentStrings, based on the game concepts. */
double[] predictAI(final Manager manager, List<String> flags, TIntArrayList flagsValues, String[] agentStrings);
}
| 491 | 27.941176 | 113 |
java
|
Ludii
|
Ludii-master/Mining/src/agentPrediction/internal/models/LinearRegression.java
|
package agentPrediction.internal.models;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import gnu.trove.list.array.TIntArrayList;
import manager.Manager;
public class LinearRegression implements BaseModel
{
//-------------------------------------------------------------------------
@Override
public String modelName()
{
return "LinearRegression";
}
//-------------------------------------------------------------------------
@Override
public double[] predictAI(final Manager manager, final List<String> flags, final TIntArrayList flagsValues, final String[] agentStrings)
{
final double[] agentPredictions = {0.0, 0.0, 0.0, 0.0};
for (int agentIndex = 0; agentIndex < agentStrings.length; agentIndex++)
{
double predictedScore = 0;
// Open CSV, and record all the values.
final Map<String, Double> entries = new HashMap<String, Double>();
// Load the csv model file.
final String filePath = "/predictionModels/" + modelName() + "/" + agentStrings[agentIndex] + ".csv";
System.out.println(filePath);
final InputStream in = LinearRegression.class.getResourceAsStream(filePath);
if (in != null)
{
try (final BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8")))
{
for (String line; (line = reader.readLine()) != null; /**/)
{
final String[] lineSplit = line.split(Pattern.quote(","));
if (lineSplit.length > 1)
entries.put(lineSplit[1], Double.valueOf(lineSplit[0]));
else
predictedScore = Double.valueOf(lineSplit[0]).doubleValue();
}
}
catch (final IOException e)
{
e.printStackTrace();
}
// Calculate the score for this agent.
for (final Map.Entry<String,Double> entry : entries.entrySet())
{
for (int i = 0; i < flags.size(); i++)
{
if (flags.get(i).equals(entry.getKey()))
{
final int flagIndex = flagsValues.get(i);
final int flagValue = manager.ref().context().game().booleanConcepts().get(flagIndex) ? 1 : 0;
predictedScore += entry.getValue().doubleValue() * flagValue;
break;
}
}
}
}
else
{
System.out.println("Failed to load agent prediction CSV for " + modelName() + ", " + agentStrings[agentIndex]);
}
agentPredictions[agentIndex] = predictedScore;
}
return agentPredictions;
}
//-------------------------------------------------------------------------
}
| 2,631 | 27.608696 | 138 |
java
|
Ludii
|
Ludii-master/Mining/src/cluster/ConceptAverageValue.java
|
package cluster;
import other.concept.Concept;
/**
* A concept associated with a value.
* Used to sort a list.
* @author Eric.Piette
*
*/
public class ConceptAverageValue
{
/**
* The concept.
*/
final Concept concept;
/**
* The value associated with the concept.
*/
final double value;
public ConceptAverageValue(
final Concept concept,
final double value
)
{
this.concept = concept;
this.value = value;
}
}
| 447 | 12.575758 | 42 |
java
|
Ludii
|
Ludii-master/Mining/src/cluster/ConceptsComparaisonClusters.java
|
package cluster;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import game.Game;
import main.FileHandling;
import main.StringRoutines;
import main.UnixPrintWriter;
import main.options.Ruleset;
import other.GameLoader;
import other.concept.Concept;
import other.concept.ConceptComputationType;
import other.concept.ConceptDataType;
import other.concept.ConceptType;
import utils.RulesetNames;
/**
* Generate the percentage of concepts from a list of rulesets.
* @author Eric.Piette
*
*/
public class ConceptsComparaisonClusters
{
final static String pathFile = "./res/cluster/input/clusters/";
final static String csv = ".csv";
final static String outputConcept = "ConceptsForCluster.csv";
/**
* Main method to call the reconstruction with command lines.
* @param args
* @throws IOException
* @throws FileNotFoundException
*/
@SuppressWarnings("boxing")
public static void main(final String[] args) throws FileNotFoundException, IOException
{
final String[] clusters = {"Cluster1.1", "Cluster1.2", "Cluster1.3", "Cluster1.4", "Cluster1.5", "Cluster1.6",
"Cluster2.1", "Cluster2.2", "Cluster2.3", "Cluster2.4", "Cluster2.5", "Cluster2.6", "Cluster2.7", "Cluster2.8",
"Cluster3.1", "Cluster3.2", "Cluster3.3", "Cluster3.4", "Cluster3.5", "Cluster3.6",
"Cluster3.7", "Cluster3.8", "Cluster3.9", "Cluster3.10", "Cluster3.11", "Cluster3.12",
"Cluster4"};
// final String[] clusters = {"Cluster1.1", "Cluster1.2"};
final List<List<ConceptAverageValue>> results = new ArrayList<List<ConceptAverageValue>>();
// Get the list of the right concepts.
final List<Concept> concepts = new ArrayList<Concept>();
for(Concept concept: Concept.values())
{
if((concept.type().equals(ConceptType.Start) || concept.type().equals(ConceptType.End) || concept.type().equals(ConceptType.Play)
|| concept.type().equals(ConceptType.Meta)|| concept.type().equals(ConceptType.Container)|| concept.type().equals(ConceptType.Component))
&& (concept.computationType().equals(ConceptComputationType.Compilation))
)
{
concepts.add(concept);
}
}
try (final PrintWriter writer = new UnixPrintWriter(new File(outputConcept), "UTF-8"))
{
final List<String> lineToWrite = new ArrayList<String>();
lineToWrite.add("");
for(String clusterName : clusters)
lineToWrite.add(clusterName);
writer.println(StringRoutines.join(",", lineToWrite));
int numConcepts = 0;
for(String clusterName : clusters)
{
// Get the list of ruleset names.
final List<String> rulesetNames = new ArrayList<String>();
try (BufferedReader br = new BufferedReader(new FileReader(pathFile + clusterName + csv)))
{
String line = br.readLine();
while (line != null)
{
rulesetNames.add(line);
line = br.readLine();
}
}
// Conversion to Game object
final List<Game> rulesetsCompiled = new ArrayList<Game>();
final String[] gameNames = FileHandling.listGames();
for (int index = 0; index < gameNames.length; index++)
{
final String gameName = gameNames[index];
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/bad/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/wip/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/WishlistDLP/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/test/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("subgame"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("reconstruction"))
continue;
final Game game = GameLoader.loadGameFromName(gameName);
final List<Ruleset> rulesetsInGame = game.description().rulesets();
// Get all the rulesets of the game if it has some.
if (rulesetsInGame != null && !rulesetsInGame.isEmpty())
{
for (int rs = 0; rs < rulesetsInGame.size(); rs++)
{
final Ruleset ruleset = rulesetsInGame.get(rs);
if (!ruleset.optionSettings().isEmpty() && !ruleset.heading().contains("Incomplete"))
{
final Game gameRuleset = GameLoader.loadGameFromName(gameName, ruleset.heading());
final String rulesetName = RulesetNames.gameRulesetName(gameRuleset);
if(rulesetNames.contains(rulesetName))
rulesetsCompiled.add(gameRuleset);
}
}
}
else
{
final String rulesetName = RulesetNames.gameRulesetName(game);
if(rulesetNames.contains(rulesetName))
rulesetsCompiled.add(game);
}
}
System.out.println(clusterName);
System.out.println("Num compiled rulesets is " + rulesetsCompiled.size());
System.out.println("*****************************");
// for(Game gameRuleset: rulesetsCompiled)
// System.out.println(RulesetNames.gameRulesetName(gameRuleset));
final List<ConceptAverageValue> conceptAverageValues = new ArrayList<ConceptAverageValue>();
// Check boolean concepts
for(Concept concept: concepts)
{
if(concept.dataType().equals(ConceptDataType.BooleanData))
{
int count = 0;
for(Game gameRuleset: rulesetsCompiled)
if(gameRuleset.booleanConcepts().get(concept.id()))
count++;
final double average = ((double) count * 100) / rulesetsCompiled.size();
final ConceptAverageValue conceptAverageValue = new ConceptAverageValue(concept, average);
conceptAverageValues.add(conceptAverageValue);
}
}
// booleanConceptAverageValues.sort((c1, c2) -> { return (c2.value - c1.value) > 0 ? 1 : (c2.value - c1.value) < 0 ? -1 : 0;});
// Check numerical concepts
for(Concept concept: concepts)
{
if(concept.dataType().equals(ConceptDataType.IntegerData) || concept.dataType().equals(ConceptDataType.IntegerData))
{
int count = 0;
for(Game gameRuleset: rulesetsCompiled)
if(gameRuleset.nonBooleanConcepts().get(concept.id()) != null)
count += Double.parseDouble(gameRuleset.nonBooleanConcepts().get(concept.id()));
final double average = (double) count / (double) rulesetsCompiled.size();
final ConceptAverageValue conceptAverageValue = new ConceptAverageValue(concept, average);
conceptAverageValues.add(conceptAverageValue);
}
}
numConcepts = conceptAverageValues.size();
results.add(conceptAverageValues);
System.out.println(clusterName + " Average concepts computed");
// numericalConceptAverageValues.sort((c1, c2) -> { return (c2.value - c1.value) > 0 ? 1 : (c2.value - c1.value) < 0 ? -1 : 0;});
}
for(int i = 0; i < numConcepts; i++)
{
final List<String> lineToWriteConcept = new ArrayList<String>();
lineToWriteConcept.add(results.get(0).get(i).concept.name());
for(List<ConceptAverageValue> conceptAverage : results)
lineToWriteConcept.add(""+conceptAverage.get(i).value);
writer.println(StringRoutines.join(",", lineToWriteConcept));
}
}
catch (final FileNotFoundException | UnsupportedEncodingException e)
{
e.printStackTrace();
}
System.out.println("Done.");
}
}
| 7,490 | 35.014423 | 142 |
java
|
Ludii
|
Ludii-master/Mining/src/cluster/ConceptsFromCluster.java
|
package cluster;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import game.Game;
import main.FileHandling;
import main.options.Ruleset;
import other.GameLoader;
import other.concept.Concept;
import other.concept.ConceptDataType;
import other.concept.ConceptType;
import utils.RulesetNames;
/**
* Generate the percentage of concepts from a list of rulesets.
* @author Eric.Piette
*
*/
public class ConceptsFromCluster
{
final static String listRulesets = "./res/cluster/input/clusters/Cluster4.csv";
final static String nameCluster = "Cluster 4";
/**
* Main method to call the reconstruction with command lines.
* @param args
* @throws IOException
* @throws FileNotFoundException
*/
@SuppressWarnings("boxing")
public static void main(final String[] args) throws FileNotFoundException, IOException
{
// Get the list of ruleset names.
final List<String> rulesetNames = new ArrayList<String>();
try (BufferedReader br = new BufferedReader(new FileReader(listRulesets)))
{
String line = br.readLine();
while (line != null)
{
rulesetNames.add(line);
line = br.readLine();
}
}
// Conversion to Game object
final List<Game> rulesetsCompiled = new ArrayList<Game>();
final String[] gameNames = FileHandling.listGames();
for (int index = 0; index < gameNames.length; index++)
{
final String gameName = gameNames[index];
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/bad/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/wip/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/WishlistDLP/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("/lud/test/"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("subgame"))
continue;
if (gameName.replaceAll(Pattern.quote("\\"), "/").contains("reconstruction"))
continue;
final Game game = GameLoader.loadGameFromName(gameName);
final List<Ruleset> rulesetsInGame = game.description().rulesets();
// Get all the rulesets of the game if it has some.
if (rulesetsInGame != null && !rulesetsInGame.isEmpty())
{
for (int rs = 0; rs < rulesetsInGame.size(); rs++)
{
final Ruleset ruleset = rulesetsInGame.get(rs);
if (!ruleset.optionSettings().isEmpty() && !ruleset.heading().contains("Incomplete"))
{
final Game gameRuleset = GameLoader.loadGameFromName(gameName, ruleset.heading());
final String rulesetName = RulesetNames.gameRulesetName(gameRuleset);
if(rulesetNames.contains(rulesetName))
rulesetsCompiled.add(gameRuleset);
}
}
}
else
{
final String rulesetName = RulesetNames.gameRulesetName(game);
if(rulesetNames.contains(rulesetName))
rulesetsCompiled.add(game);
}
}
System.out.println(nameCluster);
System.out.println("Num compiled rulesets is " + rulesetsCompiled.size());
System.out.println("*****************************");
// for(Game gameRuleset: rulesetsCompiled)
// System.out.println(RulesetNames.gameRulesetName(gameRuleset));
final List<Concept> concepts = new ArrayList<Concept>();
for(Concept concept: Concept.values())
{
if(concept.type().equals(ConceptType.Start) || concept.type().equals(ConceptType.End) || concept.type().equals(ConceptType.Play)
|| concept.type().equals(ConceptType.Meta)|| concept.type().equals(ConceptType.Container)|| concept.type().equals(ConceptType.Component)
)
{
concepts.add(concept);
}
}
System.out.println("\n\n***Boolean concepts in average***\n");
final List<ConceptAverageValue> booleanConceptAverageValues = new ArrayList<ConceptAverageValue>();
// Check boolean concepts
for(Concept concept: concepts)
{
if(concept.dataType().equals(ConceptDataType.BooleanData))
{
int count = 0;
for(Game gameRuleset: rulesetsCompiled)
if(gameRuleset.booleanConcepts().get(concept.id()))
count++;
final double average = ((double) count * 100) / rulesetsCompiled.size();
final ConceptAverageValue conceptAverageValue = new ConceptAverageValue(concept, average);
booleanConceptAverageValues.add(conceptAverageValue);
}
}
booleanConceptAverageValues.sort((c1, c2) -> { return (c2.value - c1.value) > 0 ? 1 : (c2.value - c1.value) < 0 ? -1 : 0;});
for(ConceptAverageValue concept : booleanConceptAverageValues)
System.out.println(concept.concept.name() + "," + concept.value);
System.out.println("\n\n***Numerical concepts in average***\n");
final List<ConceptAverageValue> numericalConceptAverageValues = new ArrayList<ConceptAverageValue>();
// Check numerical concepts
for(Concept concept: concepts)
{
if(concept.dataType().equals(ConceptDataType.IntegerData))
{
int count = 0;
for(Game gameRuleset: rulesetsCompiled)
if(gameRuleset.nonBooleanConcepts().get(concept.id()) != null)
count += Double.parseDouble(gameRuleset.nonBooleanConcepts().get(concept.id()));
final double average = (double) count / (double) rulesetsCompiled.size();
final ConceptAverageValue conceptAverageValue = new ConceptAverageValue(concept, average);
numericalConceptAverageValues.add(conceptAverageValue);
}
if(concept.dataType().equals(ConceptDataType.DoubleData))
{
double count = 0;
for(Game gameRuleset: rulesetsCompiled)
if(gameRuleset.nonBooleanConcepts().get(concept.id()) != null)
count += Double.parseDouble(gameRuleset.nonBooleanConcepts().get(concept.id()));
final double average = count / rulesetsCompiled.size();
final ConceptAverageValue conceptAverageValue = new ConceptAverageValue(concept, average);
numericalConceptAverageValues.add(conceptAverageValue);
}
}
numericalConceptAverageValues.sort((c1, c2) -> { return (c2.value - c1.value) > 0 ? 1 : (c2.value - c1.value) < 0 ? -1 : 0;});
for(ConceptAverageValue concept : numericalConceptAverageValues)
System.out.println(concept.concept.name() + "," + concept.value);
}
}
| 6,240 | 34.061798 | 141 |
java
|
Ludii
|
Ludii-master/Mining/src/cluster/GenerateClusters.java
|
package cluster;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* Generate the clusters based on the coordinates obtained with Sklearn.
* @author Eric.Piette
*
*/
public class GenerateClusters
{
// Coordinates of the 4 main clusters
// final static int numClusters = 4;
// // Cluster 1 area
// final static int xMinCluster1 = -50;
// final static int xMaxCluster1 = 0;
// final static int yMinCluster1 = -40;
// final static int yMaxCluster1 = 20;
//
// // Cluster 2 area
// final static int xMinCluster2 = -30;
// final static int xMaxCluster2 = 10;
// final static int yMinCluster2 = 20;
// final static int yMaxCluster2 = 50;
//
// // Cluster 3 area
// final static int xMinCluster3 = 0;
// final static int xMaxCluster3 = 40;
// final static int yMinCluster3 = -30;
// final static int yMaxCluster3 = 20;
//
// // Cluster 4 area
// final static int xMinCluster4 = 40;
// final static int xMaxCluster4 = 70;
// final static int yMinCluster4 = -40;
// final static int yMaxCluster4 = 10;
// Coordinates of the 4 sub-clusters of Cluster 1
// final static String coordinatesPath = "./res/cluster/input/coordinatesCluster1.csv";
// final static int numClusters = 6;
//
// // Cluster 1.1 area
// final static int xMinCluster1 = -15;
// final static double xMaxCluster1 = -2.4;
// final static int yMinCluster1 = -15;
// final static int yMaxCluster1 = 0;
//
// // Cluster 1.2 area
// final static int xMinCluster2 = -1;
// final static double xMaxCluster2 = 7.5;
// final static int yMinCluster2 = -15;
// final static int yMaxCluster2 = -4;
//
// // Cluster 1.3 area
// final static double xMinCluster3 = -2.45;
// final static int xMaxCluster3 = 5;
// final static int yMinCluster3 = -3;
// final static double yMaxCluster3 = 5.44;
//
// // Cluster 1.4 area
// final static int xMinCluster4 = 3;
// final static int xMaxCluster4 = 17;
// final static int yMinCluster4 = 7;
// final static int yMaxCluster4 = 16;
//
// // Cluster 1.5 area
// final static double xMinCluster5 = -4.5;
// final static int xMaxCluster5 = 1;
// final static double yMinCluster5 = 3.6;
// final static int yMaxCluster5 = 9;
//
// // Cluster 1.6 area
// final static int xMinCluster6 = 11;
// final static double xMaxCluster6 = 12.25;
// final static int yMinCluster6 = 4;
// final static double yMaxCluster6 = 6.5;
// Coordinates of the 5 sub-clusters of Cluster 2
// final static String coordinatesPath = "./res/cluster/input/coordinatesCluster2.csv";
// final static int numClusters = 8;
//
// // Cluster 2.1 area
// final static int xMinCluster1 = -10;
// final static int xMaxCluster1 = -6;
// final static double yMinCluster1 = -7.5;
// final static double yMaxCluster1 = -3.6;
//
// // Cluster 2.2 area
// final static int xMinCluster2 = -14;
// final static int xMaxCluster2 = -8;
// final static double yMinCluster2 = -0.75;
// final static int yMaxCluster2 = 4;
//
// final static double secondxMinCluster2 = -8.2;
// final static double secondxMaxCluster2 = -6.8;
// final static double secondyMinCluster2 = 2.2;
// final static int secondyMaxCluster2 = 3;
//
// // Cluster 2.3 area
// final static double xMinCluster3 = -1.2;
// final static int xMaxCluster3 = 5;
// final static int yMinCluster3 = -7;
// final static double yMaxCluster3 = -2.8;
//
// final static double secondxMinCluster3 = 5.3;
// final static double secondxMaxCluster3 = 7;
// final static double secondyMinCluster3 = -2.75;
// final static int secondyMaxCluster3 = -1;
//
// // Cluster 2.4 area
// final static double xMinCluster4 = -5.8;
// final static double xMaxCluster4 = -0.94;
// final static int yMinCluster4 = 2;
// final static double yMaxCluster4 = 5.5;
//
// // Cluster 2.5 area
// final static double xMinCluster5 = -0.77;
// final static int xMaxCluster5 = 2;
// final static double yMinCluster5 = 1.75;
// final static double yMaxCluster5 = 4.5;
//
// // Cluster 2.6 area
// final static double xMinCluster6 = 4.25;
// final static int xMaxCluster6 = 6;
// final static double yMinCluster6 = 5.5;
// final static double yMaxCluster6 = 7.0;
//
// // Cluster 2.7 area
// final static double xMinCluster7 = 1;
// final static double xMaxCluster7 = 4.5;
// final static double yMinCluster7 = 0;
// final static double yMaxCluster7 = 1.25;
//
// // Cluster 2.8 area
// final static double xMinCluster8 = -1.7;
// final static double xMaxCluster8 = 0;
// final static double yMinCluster8 = -2.5;
// final static double yMaxCluster8 = 0.8;
// Coordinates of the 9 sub-clusters of Cluster 3
final static String coordinatesPath = "./res/cluster/input/coordinatesCluster3.csv";
final static int numClusters = 12;
// Cluster 3.1 area
final static int xMinCluster1 = -4;
final static double xMaxCluster1 = 3;
final static double yMinCluster1 = 10.8;
final static int yMaxCluster1 = 19;
// Cluster 3.2 area
final static double xMinCluster2 = 6.5;
final static int xMaxCluster2 = 12;
final static double yMinCluster2 = 5.4;
final static int yMaxCluster2 = 12;
// Cluster 3.3 area
final static double xMinCluster3 = 5.4;
final static int xMaxCluster3 = 13;
final static double yMinCluster3 = -2.3;
final static int yMaxCluster3 = 3;
// Cluster 3.4 area
final static double xMinCluster4 = 6.5;
final static double xMaxCluster4 = 11;
final static double yMinCluster4 = -7;
final static int yMaxCluster4 = -3;
// Cluster 3.5 area
final static double xMinCluster5 = 4.8;
final static double xMaxCluster5 = 8;
final static double yMinCluster5 = -10;
final static double yMaxCluster5 = -7.5;
// Cluster 3.6 area
final static double xMinCluster6 = -1.5;
final static double xMaxCluster6 = 5;
final static double yMinCluster6 = -13.4;
final static double yMaxCluster6 = -9.8;
final static double secondxMinCluster6 = -3.5;
final static double secondxMaxCluster6 = 3;
final static double secondyMinCluster6 = -11.58;
final static double secondyMaxCluster6 = -8.3;
final static double thirdxMinCluster6 = -1.6;
final static double thirdxMaxCluster6 = 2;
final static double thirdyMinCluster6 = -9.45;
final static double thirdyMaxCluster6 = -7.28;
// Cluster 3.7 area
final static double xMinCluster7 = -11.66;
final static double xMaxCluster7 = -5.22;
final static double yMinCluster7 = -6.30;
final static double yMaxCluster7 = 0.25;
final static double secondxMinCluster7 = -7.35;
final static double secondxMaxCluster7 = -4;
final static double secondyMinCluster7 = 1.0;
final static double secondyMaxCluster7 = 2.25;
// Cluster 3.8 area
final static double xMinCluster8 = -18;
final static double xMaxCluster8 = -11;
final static double yMinCluster8 = -2.3;
final static double yMaxCluster8 = 1.3;
// Cluster 3.9 area
final static double xMinCluster9 = -10.9;
final static double xMaxCluster9 = -6;
final static double yMinCluster9 = 4.4;
final static double yMaxCluster9 = 8.1;
// Cluster 3.10 area
final static double xMinCluster10 = -3;
final static double xMaxCluster10 = 0.8;
final static double yMinCluster10 = 1.31;
final static double yMaxCluster10 = 9;
// Cluster 3.11 area
final static double xMinCluster11 = 1.43;
final static double xMaxCluster11 = 6;
final static double yMinCluster11 = 6;
final static double yMaxCluster11 = 10;
// Cluster 3.12 area
final static double xMinCluster12 = -5.2;
final static double xMaxCluster12 = -0.55;
final static double yMinCluster12 = -5.45;
final static double yMaxCluster12 = -0.9;
final static String gamePath = "./res/cluster/input/Games.csv";
/**
* Main method to call the reconstruction with command lines.
* @param args
* @throws IOException
* @throws FileNotFoundException
*/
@SuppressWarnings("unchecked")
public static void main(final String[] args) throws FileNotFoundException, IOException
{
// init game names list
final List<String> gameNames = new ArrayList<String>();
try (BufferedReader br = new BufferedReader(new FileReader(gamePath)))
{
String line = br.readLine();
while (line != null)
{
gameNames.add(line.substring(1, line.length()-1)); // we remove the quotes.
line = br.readLine();
}
}
// init the clusters results;
final List<String>[] clusters = new ArrayList[numClusters];
for(int i = 0; i < numClusters; i++)
clusters[i] = new ArrayList<String>();
// Read the CSV line by line.
final List<String> coordinates = new ArrayList<String>();
try (BufferedReader br = new BufferedReader(new FileReader(coordinatesPath)))
{
String line = br.readLine();
while (line != null)
{
coordinates.add(line);
line = br.readLine();
}
}
for(int i = 0; i < coordinates.size(); i++)
{
String[] gameAndCoordinates = coordinates.get(i).split(";");
final String gameName = gameAndCoordinates[0];
final double x = Double.parseDouble(gameAndCoordinates[1]);
final double y = Double.parseDouble(gameAndCoordinates[2]);
if(x >= xMinCluster1 && x <= xMaxCluster1 && y >= yMinCluster1 && y <= yMaxCluster1)
clusters[0].add(gameName);
else if(x >= xMinCluster2 && x <= xMaxCluster2 && y >= yMinCluster2 && y <= yMaxCluster2)
clusters[1].add(gameName);
else if(x >= xMinCluster3 && x <= xMaxCluster3 && y >= yMinCluster3 && y <= yMaxCluster3)
clusters[2].add(gameName);
else if(x >= xMinCluster4 && x <= xMaxCluster4 && y >= yMinCluster4 && y <= yMaxCluster4)
clusters[3].add(gameName);
else if(x >= xMinCluster5 && x <= xMaxCluster5 && y >= yMinCluster5 && y <= yMaxCluster5)
clusters[4].add(gameName);
else if(x >= xMinCluster6 && x <= xMaxCluster6 && y >= yMinCluster6 && y <= yMaxCluster6)
clusters[5].add(gameName);
else if(x >= secondxMinCluster6 && x <= secondxMaxCluster6 && y >= secondyMinCluster6 && y <= secondyMaxCluster6)
clusters[5].add(gameName);
else if(x >= thirdxMinCluster6 && x <= thirdxMaxCluster6 && y >= thirdyMinCluster6 && y <= thirdyMaxCluster6)
clusters[5].add(gameName);
else if(x >= xMinCluster7 && x <= xMaxCluster7 && y >= yMinCluster7 && y <= yMaxCluster7)
clusters[6].add(gameName);
else if(x >= secondxMinCluster7 && x <= secondxMaxCluster7 && y >= secondyMinCluster7 && y <= secondyMaxCluster7)
clusters[6].add(gameName);
else if(x >= xMinCluster8 && x <= xMaxCluster8 && y >= yMinCluster8 && y <= yMaxCluster8)
clusters[7].add(gameName);
else if(x >= xMinCluster9 && x <= xMaxCluster9 && y >= yMinCluster9 && y <= yMaxCluster9)
clusters[8].add(gameName);
else if(x >= xMinCluster10 && x <= xMaxCluster10 && y >= yMinCluster10 && y <= yMaxCluster10)
clusters[9].add(gameName);
else if(x >= xMinCluster11 && x <= xMaxCluster11 && y >= yMinCluster11 && y <= yMaxCluster11)
clusters[10].add(gameName);
else if(x >= xMinCluster12 && x <= xMaxCluster12 && y >= yMinCluster12 && y <= yMaxCluster12)
clusters[11].add(gameName);
else
System.err.println(gameName + " does not go to any cluster");
}
for(int i = 0; i < numClusters; i++)
{
System.out.println("****************** Cluster " + (i + 1) + " **************************");
for(int j = 0; j < clusters[i].size(); j++)
System.out.println(clusters[i].get(j));
System.out.println("*****Size = " + clusters[i].size());
System.out.println();
}
final String SQLRequest = "SELECT DISTINCT GameRulesets.Id AS GameRulesetsId, GameRulesets.Name AS GameRulesetsName, Games.Id AS GamesId, Games.Name AS GamesName FROM GameRulesets, Games, RulesetConcepts WHERE Games.Id = GameRulesets.GameId AND RulesetConcepts.RulesetId = GameRulesets.Id AND (GameRulesets.Type = 1 OR GameRulesets.Type = 3) AND Games.DLPGame = 1 AND (";
String SQLRequestCluster1 = SQLRequest;
String SQLRequestCluster2 = SQLRequest;
String SQLRequestCluster3 = SQLRequest;
String SQLRequestCluster4 = SQLRequest;
// Request for Cluster 1.
for(int i = 0; i < clusters[0].size() - 1; i++)
{
String gameName = clusters[0].get(i);
//System.out.println("test for " + fullGameName);
boolean found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
//System.out.println("Test: " + possibleGameName);
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster1 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster1 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
if(!found)
{
System.err.println(clusters[0].get(i) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
String gameName = clusters[0].get(clusters[0].size()-1);
//System.out.println("test for " + fullGameName);
boolean found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
//System.out.println("Test: " + possibleGameName);
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster1 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster1 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
System.err.println(clusters[0].get(clusters[0].size()-1) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
// Request for Cluster 2.
for(int i = 0; i < clusters[1].size() - 1; i++)
{
gameName = clusters[1].get(i);
//System.out.println("test for " + fullGameName);
found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
//System.out.println("Test: " + possibleGameName);
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster2 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster2 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
if(!found)
{
System.err.println(clusters[1].get(i) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
gameName = clusters[1].get(clusters[1].size()-1);
//System.out.println("test for " + fullGameName);
found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
//System.out.println("Test: " + possibleGameName);
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster2 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster2 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
System.err.println(clusters[1].get(clusters[1].size()-1) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
// Request for Cluster 3.
for(int i = 0; i < clusters[2].size() - 1; i++)
{
gameName = clusters[2].get(i);
//System.out.println("test for " + fullGameName);
found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster3 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster3 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
if(!found)
{
System.err.println(clusters[2].get(i) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
gameName = clusters[2].get(clusters[2].size()-1);
//System.out.println("test for " + fullGameName);
found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
//System.out.println("Test: " + possibleGameName);
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster3 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster3 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
System.err.println(clusters[2].get(clusters[2].size()-1) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
// Request for Cluster 4.
for(int i = 0; i < clusters[3].size() - 1; i++)
{
gameName = clusters[3].get(i);
//System.out.println("test for " + fullGameName);
found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
//System.out.println("Test: " + possibleGameName);
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster4 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster4 += "Games.Name = \\\"" + gameName + "\\\" OR ";
break;
}
}
if(!found)
{
System.err.println(clusters[3].get(i) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
gameName = clusters[3].get(clusters[3].size()-1);
//System.out.println("test for " + fullGameName);
found = false;
while(!found)
{
String gameNameWithUnderscore = gameName.substring(0, gameName.lastIndexOf('_'));
gameName = gameNameWithUnderscore.replace('_', ' ');
//System.out.println("Test: " + possibleGameName);
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster4 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
gameName = gameNameWithUnderscore;
if(!gameName.contains("_")) // If this is reached, the game name is never found.
{
for(int j = 0; j < gameNames.size(); j++)
{
if(gameNames.get(j).replace("'","").replace("(","").replace(")","").equals(gameName))
{
found = true;
gameName = gameNames.get(j);
SQLRequestCluster4 += "Games.Name = \\\"" + gameName + "\\\")";
break;
}
}
if(!found)
{
System.err.println(clusters[3].get(clusters[3].size()-1) + " is never found in the list of game names.");
System.exit(1);
}
}
}
}
System.out.println(SQLRequestCluster1);
System.out.println("********************");
System.out.println(SQLRequestCluster2);
System.out.println("********************");
System.out.println(SQLRequestCluster3);
System.out.println("********************");
System.out.println(SQLRequestCluster4);
}
}
| 22,835 | 31.254237 | 373 |
java
|
Ludii
|
Ludii-master/Mining/src/contextualiser/ContextualSimilarity.java
|
package contextualiser;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.HashMap;
import java.util.Map;
import game.Game;
import utils.DBGameInfo;
public class ContextualSimilarity
{
//-------------------------------------------------------------------------
public static final String rulesetIdsFilePath = "../Mining/res/concepts/input/GameRulesets.csv";
public static final String rulesetContextualiserFilePath = "../Mining/res/recons/input/contextualiser_1000/similarity_";
public static final String rulesetGeographicDistanceFilePath = "../Mining/res/recons/input/rulesetGeographicalDistances.csv";
public static final String rulesetYearDistanceFilePath = "../Mining/res/recons/input/rulesetYearDistances.csv";
//-------------------------------------------------------------------------
/**
* @param game Game to compare similarity against.
* @param conceptSimilarity true if using concept similarity, otherwise using cultural similarity.
* @return Map of game/ruleset names to similarity values.
*/
public static final Map<String, Double> getRulesetSimilarities(final Game game, final boolean conceptSimilarity)
{
// Get all ruleset ids from DB
final String name = DBGameInfo.getUniqueName(game);
final Map<String, Integer> rulesetIds = DBGameInfo.getRulesetIds(rulesetIdsFilePath);
final int rulesetId = rulesetIds.get(name).intValue();
final Map<Integer, Double> rulesetSimilaritiesIds = new HashMap<>(); // Map of ruleset ids to similarity
final Map<String, Double> rulesetSimilaritiesNames = new HashMap<>(); // Map of game/ruleset names to similarity
final String fileName = rulesetContextualiserFilePath + rulesetId + ".csv";
try (BufferedReader br = new BufferedReader(new FileReader(fileName)))
{
br.readLine(); // Skip first line of column headers.
String line;
while ((line = br.readLine()) != null)
{
final String[] values = line.split(",");
double similarity = -1.0;
if (conceptSimilarity)
similarity = Double.valueOf(values[2]).doubleValue();
else
similarity = Double.valueOf(values[1]).doubleValue();
rulesetSimilaritiesIds.put(Integer.valueOf(values[0]), Double.valueOf(similarity));
if (!rulesetIds.containsValue(Integer.valueOf(values[0])))
System.out.println("ERROR, two rulesets with the same name. ruleset id: " + Integer.valueOf(values[0]));
// Convert ruleset ids to corresponding names.
for (final Map.Entry<String, Integer> entry : rulesetIds.entrySet())
if (entry.getValue().equals(Integer.valueOf(values[0])))
rulesetSimilaritiesNames.put(entry.getKey(), Double.valueOf(similarity));
}
}
catch (final Exception e)
{
System.out.println("Could not find similarity file, ruleset probably has no evidence.");
e.printStackTrace();
}
return rulesetSimilaritiesNames;
}
//-------------------------------------------------------------------------
/**
* @param game Game to compare geographic similarity against.
* @return Map of game/ruleset names to similarity values.
*/
public static final Map<String, Double> getRulesetGeographicSimilarities(final Game game)
{
// Get all ruleset ids from DB
final String name = DBGameInfo.getUniqueName(game);
final Map<String, Integer> rulesetIds = DBGameInfo.getRulesetIds(rulesetIdsFilePath);
final int rulesetId = rulesetIds.get(name).intValue();
final Map<Integer, Double> rulesetSimilaritiesIds = new HashMap<>(); // Map of ruleset ids to similarity
final Map<String, Double> rulesetSimilaritiesNames = new HashMap<>(); // Map of game/ruleset names to similarity
try (BufferedReader br = new BufferedReader(new FileReader(rulesetGeographicDistanceFilePath)))
{
br.readLine(); // Skip first line of column headers.
String line;
while ((line = br.readLine()) != null)
{
final String[] values = line.split(",");
if (Integer.valueOf(values[0]).intValue() != rulesetId)
continue;
final double similarity = Math.max((20000 - Double.valueOf(values[2]).doubleValue()) / 20000, 0); // 20000km is the maximum possible distance
rulesetSimilaritiesIds.put(Integer.valueOf(values[1]), Double.valueOf(similarity));
if (!rulesetIds.containsValue(Integer.valueOf(values[0])))
System.out.println("ERROR, two rulesets with the same name. ruleset id: " + Integer.valueOf(values[0]));
// Convert ruleset ids to corresponding names.
for (final Map.Entry<String, Integer> entry : rulesetIds.entrySet())
if (entry.getValue().equals(Integer.valueOf(values[1])))
rulesetSimilaritiesNames.put(entry.getKey(), Double.valueOf(similarity));
}
}
catch (final Exception e)
{
System.out.println("Could not find similarity file, ruleset probably has no evidence.");
e.printStackTrace();
}
return rulesetSimilaritiesNames;
}
//-------------------------------------------------------------------------
/**
* @param game Game to compare year similarity against.
* @return Map of game/ruleset names to similarity values.
*/
public static final Map<String, Double> getRulesetYearSimilarities(final Game game)
{
// Get all ruleset ids from DB
final String name = DBGameInfo.getUniqueName(game);
final Map<String, Integer> rulesetIds = DBGameInfo.getRulesetIds(rulesetIdsFilePath);
final int rulesetId = rulesetIds.get(name).intValue();
final Map<Integer, Double> rulesetSimilaritiesIds = new HashMap<>(); // Map of ruleset ids to similarity
final Map<String, Double> rulesetSimilaritiesNames = new HashMap<>(); // Map of game/ruleset names to similarity
try (BufferedReader br = new BufferedReader(new FileReader(rulesetYearDistanceFilePath)))
{
br.readLine(); // Skip first line of column headers.
String line;
while ((line = br.readLine()) != null)
{
final String[] values = line.split(",");
if (Integer.valueOf(values[0]).intValue() != rulesetId)
continue;
final double similarity = Math.max((5520 - Double.valueOf(values[2]).doubleValue()) / 5520, 0); // 5520 years is the maximum possible distance
rulesetSimilaritiesIds.put(Integer.valueOf(values[1]), Double.valueOf(similarity));
if (!rulesetIds.containsValue(Integer.valueOf(values[0])))
System.out.println("ERROR, two rulesets with the same name. ruleset id: " + Integer.valueOf(values[0]));
// Convert ruleset ids to corresponding names.
for (final Map.Entry<String, Integer> entry : rulesetIds.entrySet())
if (entry.getValue().equals(Integer.valueOf(values[1])))
rulesetSimilaritiesNames.put(entry.getKey(), Double.valueOf(similarity));
}
}
catch (final Exception e)
{
System.out.println("Could not find similarity file, ruleset probably has no evidence.");
e.printStackTrace();
}
return rulesetSimilaritiesNames;
}
//-------------------------------------------------------------------------
}
| 7,271 | 41.27907 | 152 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/CompareAllDistanceMetrics.java
|
package gameDistance;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import gameDistance.datasets.treeEdit.LudemeDataset;
import gameDistance.metrics.DistanceMetric;
import gameDistance.metrics.bagOfWords.Overlap;
import gameDistance.utils.DistanceUtils;
import main.DatabaseInformation;
import other.GameLoader;
/**
* Compares all distance metrics for a given set of games.
*
* Download the "TrialsRandom.zip" file from the Ludii Server.
* Copy "TrialsRandom.zip" into "Ludii/Trials/", and extract the zip to a "TrialsRandom" folder (just right click and select "Extract Here"). Making the fullPath "Ludii/Trials/TrialsRandom/".
* Run CompareAllDistanceMetrics.java
* Output for each game/ruleset is stored in Ludii/Mining/res/gameDistance/
* "byGame" folder stores the distance from a specific ruleset to all other games for all metrics.
* "byMetric" folder stores the distance between all ruleset pairs for a specific metric.
*
* Make sure to set the "overrideStoredVocabularies" variable to true if any trials or games have changed.
*
* @author matthew.stephenson
*/
public class CompareAllDistanceMetrics
{
/** Set this variable to true, if the stored vocabularies should be overwritten on the next comparison. */
final static boolean overrideStoredVocabularies = true;
//---------------------------------------------------------------------
final static String outputPath = "res/gameDistance/";
final static Dataset ludemeDataset = new LudemeDataset();
// final static Dataset compilationConceptDataset = new CompilationConceptDataset();
// final static Dataset moveConceptDataset = new MoveConceptDataset();
// final static Dataset importConceptDataset = new ImportConceptDataset();
static Map<String, Double> fullLudemeVocabulary;
// static Map<String, Double> fullCompilationConceptVocabulary;
// static Map<String, Double> fullMoveConceptVocabulary;
// static Map<String, Double> fullImportConceptDataset;
//---------------------------------------------------------------------
public static void main(final String[] args)
{
calculateVocabularies();
// Use this code to compare specific games.
// final List<String[]> gamesAndRulesetsToCompare = getSpecificGamesToCompare();
// recordAllComparisonDistances(gamesAndRulesetsToCompare.get(0), gamesAndRulesetsToCompare.get(1));
// Use this code to compare all games.
final List<String[]> gamesAndRulesetsToCompare = GameLoader.allAnalysisGameRulesetNames();
final List<String> allGameNames = new ArrayList<>();
final List<String> allRulesetNames = new ArrayList<>();
for (final String[] allGamesToComare : gamesAndRulesetsToCompare)
{
allGameNames.add(allGamesToComare[0]);
allRulesetNames.add(allGamesToComare[1]);
}
recordAllComparisonDistances(allGameNames.toArray(new String[0]), allRulesetNames.toArray(new String[0]));
}
//---------------------------------------------------------------------
/**
* Record distances for each game/ruleset comparison.
*/
private static void recordAllComparisonDistances(final String[] gamesToCompare, final String[] rulesetsToCompare)
{
// [Game, {Game, {DistanceMetric, Value}}]
final List<Map<String, Map<String, Double>>> allGameDistances = new ArrayList<>();
for (int i = 0; i < gamesToCompare.length; i++)
{
final Map<String, Map<String, Double>> gameDistances = new HashMap<>();
for (int j = 0; j < gamesToCompare.length; j++)
{
gameDistances.put
(
gamesToCompare[j] + "_" + rulesetsToCompare[j],
compareTwoGames(GameLoader.loadGameFromName(gamesToCompare[i], rulesetsToCompare[i]), GameLoader.loadGameFromName(gamesToCompare[j], rulesetsToCompare[j]))
);
}
allGameDistances.add(gameDistances);
}
storeByGameResults(gamesToCompare, rulesetsToCompare, allGameDistances);
storeByMetricResults(gamesToCompare, rulesetsToCompare, allGameDistances);
}
//---------------------------------------------------------------------
/**
* Stores the distance results in a set of .csv files, with each file representing a single game and its distance to all other games.
* @param gamesToCompare
* @param rulesetsToCompare
* @param allGameDistances
*/
@SuppressWarnings("unchecked")
private static void storeByGameResults(final String[] gamesToCompare, final String[] rulesetsToCompare, final List<Map<String, Map<String, Double>>> allGameDistances)
{
for (int i = 0; i < gamesToCompare.length; i++)
{
// Create output file.
final File outputFile = new File(outputPath + "output/byGame/" +
gamesToCompare[i].split("\\/")[gamesToCompare[i].split("\\/").length-1] + "_" +
rulesetsToCompare[i].split("\\/")[rulesetsToCompare[i].split("\\/").length-1] + ".csv");
try
{
outputFile.createNewFile();
}
catch (final IOException e1)
{
e1.printStackTrace();
}
// Store distances in output file.
try (final FileWriter myWriter = new FileWriter(outputFile))
{
// Write the top row of the csv
String topRow = "GameName,Id";
final List<String> distanceNames = new ArrayList<>(((Map<String, Double>) allGameDistances.get(i).values().toArray()[0]).keySet());
for (final String distance : distanceNames)
topRow += "," + distance;
myWriter.write(topRow + "\n");
// Store all distances for this ruleset.
for (final Map.Entry<String, Map<String, Double>> gameEntry : allGameDistances.get(i).entrySet())
{
final String gameName = gameEntry.getKey();
// Get corresponding ruleset Id.
final String[] nameArray = gameName.split("_")[0].split("/");
final String formattedGameName = nameArray[nameArray.length-1].substring(0,nameArray[nameArray.length-1].length()-4);
String formattedRulesetName = "";
if (gameName.split("_").length > 1)
formattedRulesetName = gameName.split("_")[1];
final int rulesetId = DatabaseInformation.getRulesetId(formattedGameName, formattedRulesetName);
final List<String> row = new ArrayList<>(distanceNames);
for (final Map.Entry<String, Double> distanceEntry : gameEntry.getValue().entrySet())
{
final String distanceMetric = distanceEntry.getKey();
final Double distaneValue = distanceEntry.getValue();
row.set(row.indexOf(distanceMetric), String.valueOf(distaneValue));
}
myWriter.write(gameName + "," + rulesetId + "," + String.join(",", row) + "\n");
}
myWriter.close();
}
catch (final IOException e)
{
e.printStackTrace();
}
}
}
//---------------------------------------------------------------------
/**
* Stores the distance results in a set of .csv files, with each file representing a single distance metric for all game-distance pairs.
* @param gamesToCompare
* @param rulesetsToCompare
* @param allGameDistances
*/
@SuppressWarnings("unchecked")
private static void storeByMetricResults(final String[] gamesToCompare, final String[] rulesetsToCompare, final List<Map<String, Map<String, Double>>> allGameDistances)
{
final List<String> distanceNames = new ArrayList<>(((Map<String, Double>) allGameDistances.get(0).values().toArray()[0]).keySet());
for (int i = 0; i < distanceNames.size(); i++)
{
// Create output file.
final File outputFile = new File(outputPath + "output/byMetric/" + distanceNames.get(i) + ".csv");
try
{
outputFile.createNewFile();
}
catch (final IOException e1)
{
e1.printStackTrace();
}
// Store distances in output file.
try (final FileWriter myWriter = new FileWriter(outputFile))
{
final List<String> allRulesetIds = new ArrayList<>();
// Write the top row of the file
String topRow = "Id";
for (int j = 0; j < gamesToCompare.length; j++)
{
final String gameName = gamesToCompare[j] + "_" + rulesetsToCompare[j];
// Get corresponding ruleset Id.
final String[] nameArray = gameName.split("_")[0].split("/");
final String formattedGameName = nameArray[nameArray.length-1].substring(0,nameArray[nameArray.length-1].length()-4);
String formattedRulesetName = "";
if (gameName.split("_").length > 1)
formattedRulesetName = gameName.split("_")[1];
final int rulesetId = DatabaseInformation.getRulesetId(formattedGameName, formattedRulesetName);
allRulesetIds.add(String.valueOf(rulesetId));
topRow += "," + rulesetId;
}
myWriter.write(topRow + "\n");
for (int j = 0; j < gamesToCompare.length; j++)
{
String row = allRulesetIds.get(j);
final Map<String, Map<String, Double>> distanceMapAllGames = allGameDistances.get(j);
for (int k = 0; k < gamesToCompare.length; k++)
{
final Map<String, Double> distanceMap = distanceMapAllGames.get(gamesToCompare[k] + "_" + rulesetsToCompare[k]);
row += "," + distanceMap.get(distanceNames.get(i));
}
myWriter.write(row + "\n");
}
myWriter.close();
}
catch (final IOException e)
{
e.printStackTrace();
}
}
}
//---------------------------------------------------------------------
/**
* Calculate dataset vocabularies for TFIDF measures.
*/
private static void calculateVocabularies()
{
fullLudemeVocabulary = DistanceUtils.fullVocabulary(ludemeDataset, "ludemeDataset", overrideStoredVocabularies);
System.out.println("ludemeVocabulary recorded");
// fullCompilationConceptVocabulary = DistanceUtils.fullVocabulary(compilationConceptDataset, "compilationConceptDataset", overrideStoredVocabularies);
// System.out.println("compilationConceptDataset recorded");
//
// fullMoveConceptVocabulary = DistanceUtils.fullVocabulary(moveConceptDataset, "moveConceptDataset", overrideStoredVocabularies);
// System.out.println("moveConceptVocabulary recorded");
//
// fullImportConceptDataset = DistanceUtils.fullVocabulary(importConceptDataset, "importConceptDataset", overrideStoredVocabularies);
// System.out.println("importConceptVocabulary recorded");
}
//---------------------------------------------------------------------
/**
* Compares gameA and gameB across all distance measures
* @param gameA
* @param gameB
* @return Map of distance metric names and values.
*/
public static Map<String, Double> compareTwoGames(final Game gameA, final Game gameB)
{
final Map<String, Double> allDistances = new HashMap<>();
//ludemeDataset.getTree(gameA);
System.out.println("\n" + gameA.name() + " v.s. " + gameB.name());
// //---------------------------------------------------------------------
// // Store the default vocabularies for each dataset.
//
final Map<String, Double> defaultLudemeVocabulary = DistanceUtils.defaultVocabulary(ludemeDataset, gameA, gameB);
// final Map<String, Double> defaultLudemeNGramVocabulary = DistanceUtils.defaultVocabulary(new NGramDataset(ludemeDataset, DistanceUtils.nGramLength), gameA, gameB);
//
// final Map<String, Double> defaultCompilationConceptVocabulary = DistanceUtils.defaultVocabulary(compilationConceptDataset, gameA, gameB);
//
// final Map<String, Double> defaultMoveConceptVocabulary = DistanceUtils.defaultVocabulary(moveConceptDataset, gameA, gameB);
// final Map<String, Double> defaultMoveConceptNGramVocabulary = DistanceUtils.defaultVocabulary(new NGramDataset(moveConceptDataset, DistanceUtils.nGramLength), gameA, gameB);
//
// //---------------------------------------------------------------------
// // Overlap
//
final DistanceMetric overlapDistanceMetric = new Overlap();
allDistances.put("overlap_ludeme", Double.valueOf(overlapDistanceMetric.distance(ludemeDataset, defaultLudemeVocabulary, gameA, gameB)));
//
// //---------------------------------------------------------------------
// // JensenShannonDivergence
//
// final DistanceMetric jensenShannonDivergenceMetric = new JensenShannonDivergence();
//
// allDistances.put("JSD_ludeme", jensenShannonDivergenceMetric.distance(ludemeDataset, defaultLudemeVocabulary, gameA, gameB));
// allDistances.put("JSD_compilationConcept", jensenShannonDivergenceMetric.distance(compilationConceptDataset, defaultCompilationConceptVocabulary, gameA, gameB));
// allDistances.put("JSD_moveConcept", jensenShannonDivergenceMetric.distance(moveConceptDataset, defaultMoveConceptVocabulary, gameA, gameB));
//
// allDistances.put("JSD_ludeme_ngram", jensenShannonDivergenceMetric.distance(new NGramDataset(ludemeDataset, DistanceUtils.nGramLength), defaultLudemeNGramVocabulary, gameA, gameB));
// allDistances.put("JSD_moveCooncept_ngram", jensenShannonDivergenceMetric.distance(new NGramDataset(moveConceptDataset, DistanceUtils.nGramLength), defaultMoveConceptNGramVocabulary, gameA, gameB));
//
// allDistances.put("JSD_ludeme_TFIDF", jensenShannonDivergenceMetric.distance(ludemeDataset, fullLudemeVocabulary, gameA, gameB));
// allDistances.put("JSD_compilationConcept_TFIDF", jensenShannonDivergenceMetric.distance(compilationConceptDataset, fullCompilationConceptVocabulary, gameA, gameB));
// allDistances.put("JSD_moveConcept_TFIDF", jensenShannonDivergenceMetric.distance(moveConceptDataset, fullMoveConceptVocabulary, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Cosine
//
// final DistanceMetric cosineMetric = new Cosine();
//
// allDistances.put("Cosine_ludeme", cosineMetric.distance(ludemeDataset, defaultLudemeVocabulary, gameA, gameB));
// allDistances.put("Cosine_compilationConcept", cosineMetric.distance(compilationConceptDataset, defaultCompilationConceptVocabulary, gameA, gameB));
// allDistances.put("Cosine_moveConcept", cosineMetric.distance(moveConceptDataset, defaultMoveConceptVocabulary, gameA, gameB));
//
// allDistances.put("Cosine_ludeme_ngram", cosineMetric.distance(new NGramDataset(ludemeDataset, DistanceUtils.nGramLength), defaultLudemeNGramVocabulary, gameA, gameB));
// allDistances.put("Cosine_moveCooncept_ngram", cosineMetric.distance(new NGramDataset(moveConceptDataset, DistanceUtils.nGramLength), defaultMoveConceptNGramVocabulary, gameA, gameB));
//
// allDistances.put("Cosine_ludeme_TFIDF", cosineMetric.distance(ludemeDataset, fullLudemeVocabulary, gameA, gameB));
// allDistances.put("Cosine_compilationConcept_TFIDF", cosineMetric.distance(compilationConceptDataset, fullCompilationConceptVocabulary, gameA, gameB));
// allDistances.put("Cosine_moveConcept_TFIDF", cosineMetric.distance(moveConceptDataset, fullMoveConceptVocabulary, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Jaccard
//
// final DistanceMetric jaccardMetric = new Jaccard();
//
// allDistances.put("Jaccard_ludeme", jaccardMetric.distance(ludemeDataset, defaultLudemeVocabulary, gameA, gameB));
// allDistances.put("Jaccard_compilationConcept", jaccardMetric.distance(compilationConceptDataset, defaultCompilationConceptVocabulary, gameA, gameB));
// allDistances.put("Jaccard_moveConcept", jaccardMetric.distance(moveConceptDataset, defaultMoveConceptVocabulary, gameA, gameB));
//
// allDistances.put("Jaccard_ludeme_ngram", jaccardMetric.distance(new NGramDataset(ludemeDataset, DistanceUtils.nGramLength), defaultLudemeNGramVocabulary, gameA, gameB));
// allDistances.put("Jaccard_moveCooncept_ngram", jaccardMetric.distance(new NGramDataset(moveConceptDataset, DistanceUtils.nGramLength), defaultMoveConceptNGramVocabulary, gameA, gameB));
//
// allDistances.put("Jaccard_ludeme_TFIDF", jaccardMetric.distance(ludemeDataset, fullLudemeVocabulary, gameA, gameB));
// allDistances.put("Jaccard_compilationConcept_TFIDF", jaccardMetric.distance(compilationConceptDataset, fullCompilationConceptVocabulary, gameA, gameB));
// allDistances.put("Jaccard_moveConcept_TFIDF", jaccardMetric.distance(moveConceptDataset, fullMoveConceptVocabulary, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Levenshtein
//
// final DistanceMetric levenshteinMetric = new Levenshtein();
//
// allDistances.put("Levenshtein_ludeme", levenshteinMetric.distance(ludemeDataset, null, gameA, gameB));
// allDistances.put("Levenshtein_moveConcept", levenshteinMetric.distance(moveConceptDataset, null, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Local Alignment
//
// final DistanceMetric localAlignmentMetric = new LocalAlignment();
//
// allDistances.put("LocalAlignment_ludeme", localAlignmentMetric.distance(ludemeDataset, null, gameA, gameB));
// allDistances.put("LocalAlignment_moveConcept", localAlignmentMetric.distance(moveConceptDataset, null, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Repeated Local Alignment
//
// final DistanceMetric repeatedLocalAlignmentMetric = new RepeatedLocalAlignment();
//
// allDistances.put("RepeatedLocalAlignment_ludeme", repeatedLocalAlignmentMetric.distance(ludemeDataset, null, gameA, gameB));
// allDistances.put("RepeatedLocalAlignment_moveConcept", repeatedLocalAlignmentMetric.distance(moveConceptDataset, null, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Global Alignment
//
// final DistanceMetric globalAlignmentMetric = new GlobalAlignment();
//
// allDistances.put("GlobalAlignment_ludeme", globalAlignmentMetric.distance(ludemeDataset, null, gameA, gameB));
// allDistances.put("GlobalAlignment_moveConcept", globalAlignmentMetric.distance(moveConceptDataset, null, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Zhang Shasha
//
// final DistanceMetric zhangShashaMetric = new ZhangShasha();
//
// allDistances.put("ZhangShasha_ludeme", zhangShashaMetric.distance(ludemeDataset, defaultLudemeVocabulary, gameA, gameB));
//
// //---------------------------------------------------------------------
// // Apted
//
// final DistanceMetric aptedMetric = new Apted();
//
// allDistances.put("Apted_ludeme", aptedMetric.distance(ludemeDataset, defaultLudemeVocabulary, gameA, gameB));
//---------------------------------------------------------------------
return allDistances;
}
//---------------------------------------------------------------------
}
| 18,644 | 45.037037 | 201 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/Dataset.java
|
package gameDistance.datasets;
import java.util.List;
import java.util.Map;
import game.Game;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Interface for game dataset classes.
*
* @author Matthew.Stephenson
*/
public interface Dataset
{
/**
* @return dataset in a bag of words format <FeatureName, FeatureValue>
*/
Map<String, Double> getBagOfWords(Game game);
/**
* @return dataset in a sequence format.
*/
List<String> getSequence(Game game);
/**
* @return dataset in a tree format.
*/
Tree getTree(Game game);
}
| 562 | 17.16129 | 72 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/DatasetUtils.java
|
package gameDistance.datasets;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import game.Game;
import manager.utils.game_logs.MatchRecord;
import other.trial.Trial;
/**
* Game dataset utility functions.
*
* @author matthew.stephenson
*/
public class DatasetUtils
{
//-------------------------------------------------------------------------
/**
* TODO currently the loaded trial doesn't consider rulesetStrings
*/
public static List<Trial> getSavedTrials(final Game game)
{
final List<Trial> gameTrials = new ArrayList<>();
final String folderTrials = "/../Trials/TrialsRandom/";
final File currentFolder = new File(".");
final File folder = new File(currentFolder.getAbsolutePath() + folderTrials);
final String gameName = game.name();
final String rulesetName = game.getRuleset() == null ? "" : game.getRuleset().heading();
String trialFolderPath = folder + "/" + gameName;
if(!rulesetName.isEmpty())
trialFolderPath += File.separator + rulesetName.replace("/", "_");
final File trialFolder = new File(trialFolderPath);
if(!trialFolder.exists())
System.out.println("DO NOT FOUND IT - Path is " + trialFolder);
for(final File trialFile : trialFolder.listFiles())
{
MatchRecord loadedRecord;
try
{
loadedRecord = MatchRecord.loadMatchRecordFromTextFile(trialFile, game);
final Trial loadedTrial = loadedRecord.trial();
gameTrials.add(new Trial(loadedTrial));
}
catch (final FileNotFoundException e)
{
e.printStackTrace();
}
catch (final IOException e)
{
e.printStackTrace();
}
}
return gameTrials;
}
//-------------------------------------------------------------------------
}
| 1,792 | 24.614286 | 90 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/bagOfWords/AIResultDataset.java
|
package gameDistance.datasets.bagOfWords;
import java.util.List;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Dataset containing performance results of different AI.
* - BagOfWords
*
* @author matthew.stephenson
*/
public class AIResultDataset implements Dataset
{
@Override
public Map<String, Double> getBagOfWords(final Game game)
{
return null;
}
/**
* Not Supported
*/
@Override
public List<String> getSequence(final Game game)
{
return null;
}
/**
* Not Supported
*/
@Override
public Tree getTree(final Game game)
{
return null;
}
}
| 676 | 14.386364 | 59 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/bagOfWords/CompilationConceptDataset.java
|
package gameDistance.datasets.bagOfWords;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import other.concept.Concept;
import other.concept.ConceptComputationType;
import other.concept.ConceptDataType;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Dataset containing compilation concepts.
* - BagOfWords
*
* @author matthew.stephenson
*/
public class CompilationConceptDataset implements Dataset
{
@Override
public Map<String, Double> getBagOfWords(final Game game)
{
final Map<String, Double> featureMap = new HashMap<>();
for (int i = 0; i < Concept.values().length; i++)
{
final Concept concept = Concept.values()[i];
if(concept.computationType().equals(ConceptComputationType.Compilation))
{
if (concept.dataType().equals(ConceptDataType.BooleanData))
{
if (game.booleanConcepts().get(concept.id()))
featureMap.put(concept.name(), Double.valueOf(1.0));
else
featureMap.put(concept.name(), Double.valueOf(0.0));
}
else if (concept.dataType().equals(ConceptDataType.DoubleData) || concept.dataType().equals(ConceptDataType.IntegerData))
{
featureMap.put(concept.name(), Double.valueOf(game.nonBooleanConcepts().get(Integer.valueOf(concept.id()))));
}
else
{
System.out.println("ERROR, the following concept has an invalid type " + concept.toString());
}
}
}
return featureMap;
}
/**
* Not Supported
*/
@Override
public List<String> getSequence(final Game game)
{
return null;
}
/**
* Not Supported
*/
@Override
public Tree getTree(final Game game)
{
return null;
}
}
| 1,707 | 22.39726 | 125 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/bagOfWords/ImportConceptDataset.java
|
package gameDistance.datasets.bagOfWords;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Dataset containing compilation concepts.
* - BagOfWords
*
* @author matthew.stephenson
*/
public class ImportConceptDataset implements Dataset
{
@Override
public Map<String, Double> getBagOfWords(final Game game)
{
final Map<String, Double> featureMap = new HashMap<>();
// Load files from a specific directory instead.
final String filePath = "../../LudiiPrivate/DataMiningScripts/Sklearn/res/Input/rulesetConceptsUCT.csv";
List<String> topRow = new ArrayList<>();
final List<List<String>> records = new ArrayList<>();
try (BufferedReader br = new BufferedReader(new FileReader(filePath)))
{
String line = br.readLine();
topRow = Arrays.asList(line.split(","));
while ((line = br.readLine()) != null)
{
final String[] values = line.split(",");
records.add(Arrays.asList(values));
}
}
catch (final Exception e)
{
e.printStackTrace();
}
final String gameName = game.name().replaceAll("',()", "").replace(" ", "_");
String rulesetName = "Default";
if (game.getRuleset() != null)
rulesetName = game.getRuleset().heading().replaceAll("',()", "").replace(" ", "_");
final String formattedRulesetName = gameName + "_" + rulesetName;
// find the record that matches the ruleset name:
for (final List<String> record : records)
{
if (record.get(0).equals(formattedRulesetName))
{
for (int i = 1; i < topRow.size(); i++)
{
System.out.println(i);
System.out.println(topRow.get(i));
System.out.println(Double.valueOf(record.get(i)));
featureMap.put(topRow.get(i), Double.valueOf(record.get(i)));
}
break;
}
}
System.out.println("Failed to find match for " + formattedRulesetName);
return featureMap;
}
/**
* Not Supported
*/
@Override
public List<String> getSequence(final Game game)
{
return null;
}
/**
* Not Supported
*/
@Override
public Tree getTree(final Game game)
{
return null;
}
}
| 2,336 | 23.34375 | 106 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/bagOfWords/NGramDataset.java
|
package gameDistance.datasets.bagOfWords;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Converts a Sequence-possible dataset into a BagOfWords equivalent based on NGram sets.
* - BagOfWords
*
* @author matthew.stephenson
*/
public class NGramDataset implements Dataset
{
//---------------------------------------------------------------------
Dataset originalDataset;
int nGramLength;
//---------------------------------------------------------------------
/**
* Make sure to call this constructor with a dataset that provides a sequence output format.
* @param originalDataset
* @param nGramLength
*/
public NGramDataset(final Dataset originalDataset, final int nGramLength)
{
this.originalDataset = originalDataset;
this.nGramLength = nGramLength;
}
//---------------------------------------------------------------------
@Override
public Map<String, Double> getBagOfWords(final Game game)
{
return convertSequenceToNGram(originalDataset.getSequence(game), nGramLength);
}
/**
* Not Supported
*/
@Override
public List<String> getSequence(final Game game)
{
return null;
}
/**
* Not Supported
*/
@Override
public Tree getTree(final Game game)
{
return null;
}
//---------------------------------------------------------------------
/**
* Converts from a sequence dataset output to an NGrams bagOfWords output.
*/
public static Map<String, Double> convertSequenceToNGram(final List<String> sequence, final int n)
{
final Map<String, Double> featureMap = new HashMap<>();
final List<List<String>> allNGrams = new ArrayList<>();
for (int i = 0; i < sequence.size()-n; i++)
allNGrams.add(sequence.subList(i, i+n));
final List<String> allNGramStrings = new ArrayList<>();
for (int i = 0; i < allNGrams.size(); i++)
allNGramStrings.add(String.join("_", allNGrams.get(i)));
for (final String nGramString : allNGramStrings)
{
if (featureMap.containsKey(nGramString))
featureMap.put(nGramString, Double.valueOf(featureMap.get(nGramString).doubleValue()+1.0));
else
featureMap.put(nGramString, Double.valueOf(1.0));
}
return featureMap;
}
//---------------------------------------------------------------------
}
| 2,417 | 24.1875 | 99 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/sequence/MoveConceptDataset.java
|
package gameDistance.datasets.sequence;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import gameDistance.datasets.DatasetUtils;
import gnu.trove.list.array.TIntArrayList;
import other.concept.Concept;
import other.context.Context;
import other.trial.Trial;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Dataset containing move concepts from trials.
* - BagOfWords
* - Sequence
*
* @author matthew.stephenson
*/
public class MoveConceptDataset implements Dataset
{
//-------------------------------------------------------------------------
@Override
public Map<String, Double> getBagOfWords(final Game game)
{
final Map<String, Double> featureMap = new HashMap<>();
final List<Trial> gameTrials = DatasetUtils.getSavedTrials(game);
for (int i = 0; i < gameTrials.size(); ++i)
{
final Trial trial = gameTrials.get(i);
final Trial newTrial = new Trial(game);
final Context context = new Context(game, newTrial);
game.start(context);
final TIntArrayList gameMoveConceptSet = new TIntArrayList();
for(int j = 0; j < Concept.values().length; j++)
gameMoveConceptSet.add(0);
for(int o = newTrial.numInitialPlacementMoves(); o < trial.numMoves(); o++)
{
final TIntArrayList moveConceptSet = trial.getMove(o).moveConceptsValue(context);
for(int j = 0; j < Concept.values().length; j++)
gameMoveConceptSet.set(j, gameMoveConceptSet.get(j) + moveConceptSet.get(j));
game.apply(context, trial.getMove(o));
}
for(int j = 0; j < gameMoveConceptSet.size(); j++)
featureMap.put(Concept.values()[j].name(), Double.valueOf(gameMoveConceptSet.get(j)));
}
return featureMap;
}
//-------------------------------------------------------------------------
@Override
public List<String> getSequence(final Game game)
{
final List<String> moveConceptSequence = new ArrayList<>();
final List<Trial> gameTrials = DatasetUtils.getSavedTrials(game);
// For now, just take the first trial. gameTrials.size()
for (int i = 0; i < 1; ++i)
{
final Trial trial = gameTrials.get(i);
final Trial newTrial = new Trial(game);
final Context context = new Context(game, newTrial);
game.start(context);
final ArrayList<TIntArrayList> moveConceptSet = new ArrayList<>();
for(int o = newTrial.numInitialPlacementMoves(); o < trial.numMoves(); o++)
{
moveConceptSet.add(trial.getMove(o).moveConceptsValue(context));
game.apply(context, trial.getMove(o));
}
for (int j = 0; j < moveConceptSet.size(); j++)
moveConceptSequence.add(moveConceptSet.get(j).toString());
}
return moveConceptSequence;
}
//-------------------------------------------------------------------------
/**
* Not Supported
*/
@Override
public Tree getTree(final Game game)
{
return null;
}
//-------------------------------------------------------------------------
}
| 3,031 | 27.336449 | 90 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/sequence/StateConceptDataset.java
|
package gameDistance.datasets.sequence;
import java.util.List;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Dataset containing state concepts from trials.
* - BagOfWords
* - Sequence
*
* @author matthew.stephenson
*/
public class StateConceptDataset implements Dataset
{
@Override
public Map<String, Double> getBagOfWords(final Game game)
{
return null;
}
@Override
public List<String> getSequence(final Game game)
{
return null;
}
/**
* Not Supported
*/
@Override
public Tree getTree(final Game game)
{
return null;
}
}
| 656 | 14.642857 | 59 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/datasets/treeEdit/LudemeDataset.java
|
package gameDistance.datasets.treeEdit;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import game.Game;
import gameDistance.datasets.Dataset;
import ludemeplexDetection.GetLudemeInfo;
import main.grammar.Call;
import main.grammar.LudemeInfo;
import utils.data_structures.support.zhang_shasha.Tree;
/**
* Dataset containing ludemes used for each game's description.
* - BagOfWords
* - Sequence
* - Tree
*
* @author matthew.stephenson
*/
public class LudemeDataset implements Dataset
{
//-------------------------------------------------------------------------
@Override
public Map<String, Double> getBagOfWords(final Game game)
{
final List<LudemeInfo> allLudemes = GetLudemeInfo.getLudemeInfo();
// Initialise all values to zero
final Map<String, Double> featureMap = new HashMap<>();
for (final LudemeInfo ludeme :allLudemes)
featureMap.put(ludeme.symbol().name(), Double.valueOf(0.0));
final Call callTree = game.description().callTree();
final Set<LudemeInfo> gameLudemes = callTree.analysisFormat(0, allLudemes).keySet();
for (final LudemeInfo ludeme : gameLudemes)
featureMap.put(ludeme.symbol().name(), Double.valueOf(featureMap.get(ludeme.symbol().name()).doubleValue()+1.0));
return featureMap;
}
//-------------------------------------------------------------------------
@Override
public List<String> getSequence(final Game game)
{
final List<LudemeInfo> allLudemes = GetLudemeInfo.getLudemeInfo();
final Call callTree = game.description().callTree();
final Set<LudemeInfo> gameLudemes = callTree.analysisFormat(0, allLudemes).keySet();
final List<String> ludemeSequence = new ArrayList<>();
for (final LudemeInfo ludeme : gameLudemes)
ludemeSequence.add(ludeme.symbol().name());
return ludemeSequence;
}
//-------------------------------------------------------------------------
@Override
public Tree getTree(final Game game)
{
final List<LudemeInfo> allLudemes = GetLudemeInfo.getLudemeInfo();
final Call callTree = game.description().callTree();
final String gameLudemes = callTree.preorderFormat(0, allLudemes);
final Tree ludemeTree = new Tree(gameLudemes);
return ludemeTree;
}
//-------------------------------------------------------------------------
}
| 2,356 | 28.835443 | 116 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/metrics/DistanceMetric.java
|
package gameDistance.metrics;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
/**
* Interface for distance metric classes.
*
* @author Matthew.Stephenson
*/
public interface DistanceMetric
{
/**
* @return Estimated distance between two games.
*/
double distance(final Dataset dataset, final Map<String, Double> vocabulary, final Game gameA, final Game gameB);
}
| 407 | 18.428571 | 114 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/metrics/bagOfWords/Cosine.java
|
package gameDistance.metrics.bagOfWords;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import gameDistance.metrics.DistanceMetric;
import gameDistance.utils.DistanceUtils;
import main.Constants;
//-----------------------------------------------------------------------------
/**
* https://en.wikipedia.org/wiki/Cosine_similarity
*
* @author Matthew.Stephenson, Markus
*/
public class Cosine implements DistanceMetric
{
@Override
public double distance(final Dataset dataset, final Map<String, Double> vocabulary, final Game gameA, final Game gameB)
{
final Map<String, Double> datasetA = DistanceUtils.getGameDataset(dataset, gameA);
final Map<String, Double> datasetB = DistanceUtils.getGameDataset(dataset, gameB);
double nominator = 0.0;
double denominatorA = 0.0;
double denominatorB = 0.0;
for (final String word : vocabulary.keySet())
{
double frqA = 0.0;
double frqB = 0.0;
if (datasetA.containsKey(word))
frqA = datasetA.get(word).doubleValue() * vocabulary.get(word).doubleValue();
if (datasetB.containsKey(word))
frqB = datasetB.get(word).doubleValue() * vocabulary.get(word).doubleValue();
nominator+=frqA*frqB;
denominatorA+=frqA*frqA;
denominatorB+=frqB*frqB;
}
final double denominator = Math.sqrt(denominatorA)*Math.sqrt(denominatorB);
final double finalVal = 1-(nominator/denominator);
// Handle floating point imprecision
if (finalVal < Constants.EPSILON)
return 0;
return finalVal;
}
}
| 1,525 | 26.25 | 120 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/metrics/bagOfWords/Jaccard.java
|
package gameDistance.metrics.bagOfWords;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import gameDistance.metrics.DistanceMetric;
import gameDistance.utils.DistanceUtils;
//-----------------------------------------------------------------------------
/**
* https://en.wikipedia.org/wiki/Jaccard_index
*
* @author Matthew.Stephenson, Markus
*/
public class Jaccard implements DistanceMetric
{
@Override
public double distance(final Dataset dataset, final Map<String, Double> vocabulary, final Game gameA, final Game gameB)
{
final Map<String, Double> datasetA = DistanceUtils.getGameDataset(dataset, gameA);
final Map<String, Double> datasetB = DistanceUtils.getGameDataset(dataset, gameB);
double nominator = 0.0;
double denominator = 0.0;
for (final String word : vocabulary.keySet())
{
double frqA = 0.0;
double frqB = 0.0;
if (datasetA.containsKey(word))
frqA = datasetA.get(word).doubleValue() * vocabulary.get(word).doubleValue();
if (datasetB.containsKey(word))
frqB = datasetB.get(word).doubleValue() * vocabulary.get(word).doubleValue();
nominator += Math.min(frqA,frqB);
denominator += Math.max(frqA, frqB);
}
final double finalVal = 1-(nominator/denominator);
return finalVal;
}
}
| 1,297 | 26.041667 | 120 |
java
|
Ludii
|
Ludii-master/Mining/src/gameDistance/metrics/bagOfWords/JensenShannonDivergence.java
|
package gameDistance.metrics.bagOfWords;
import java.util.Map;
import game.Game;
import gameDistance.datasets.Dataset;
import gameDistance.metrics.DistanceMetric;
import gameDistance.utils.DistanceUtils;
//-----------------------------------------------------------------------------
/**
* https://en.wikipedia.org/wiki/Jensen%E2%80%93Shannon_divergence
*
* @author Matthew.Stephenson, Sofia, Markus
*/
public class JensenShannonDivergence implements DistanceMetric
{
@Override
public double distance(final Dataset dataset, final Map<String, Double> vocabulary, final Game gameA, final Game gameB)
{
final Map<String, Double> datasetA = DistanceUtils.getGameDataset(dataset, gameA);
final Map<String, Double> datasetB = DistanceUtils.getGameDataset(dataset, gameB);
double klDiv1 = 0.0;
double klDiv2 = 0.0;
for (final String word : vocabulary.keySet())
{
double valA = 0.0;
double valB = 0.0;
if (datasetA.containsKey(word))
valA = datasetA.get(word).doubleValue() * vocabulary.get(word).doubleValue();
if (datasetB.containsKey(word))
valB = datasetB.get(word).doubleValue() * vocabulary.get(word).doubleValue();
final double avg = (valA + valB) / 2.0;
assert (avg != 0.0);
if (valA != 0.0)
klDiv1 += valA * Math.log(valA / avg);
if (valB != 0.0)
klDiv2 += valB * Math.log(valB / avg);
}
final double jensonsShannonDivergence = (klDiv1 + klDiv2) / 2.0 / Math.log(2);
return jensonsShannonDivergence;
}
}
| 1,494 | 25.696429 | 120 |
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.