code stringlengths 73 34.1k | label stringclasses 1
value |
|---|---|
private static boolean hasSync(Screen screen)
{
final Config config = screen.getConfig();
final Resolution output = config.getOutput();
return config.isWindowed() && output.getRate() > 0;
} | java |
private static int computeE1(int a, int b, int c, int d, int e, int f)
{
if (d == b && e != c || b == f && e != a)
{
return b;
}
return e;
} | java |
private static int computeE3(int a, int b, int d, int e, int g, int h)
{
if (d == b && e != g || d == h && e != a)
{
return d;
}
return e;
} | java |
private static int computeE5(int b, int c, int e, int f, int h, int i)
{
if (b == f && e != i || h == f && e != c)
{
return f;
}
return e;
} | java |
private static int computeE7(int d, int e, int f, int g, int h, int i)
{
if (d == h && e != i || h == f && e != g)
{
return h;
}
return e;
} | java |
public static ActionConfig imports(Configurer configurer)
{
Check.notNull(configurer);
return imports(configurer.getRoot());
} | java |
public static ActionConfig imports(Xml root)
{
Check.notNull(root);
final Xml nodeAction = root.getChild(NODE_ACTION);
final String name = nodeAction.readString(ATT_NAME);
final String description = nodeAction.readString(ATT_DESCRIPTION);
final int x = nodeAction.read... | java |
public static Xml exports(ActionConfig config)
{
Check.notNull(config);
final Xml nodeAction = new Xml(NODE_ACTION);
nodeAction.writeString(ATT_NAME, config.getName());
nodeAction.writeString(ATT_DESCRIPTION, config.getDescription());
nodeAction.writeInteger(ATT_X, co... | java |
public int setParent(Node parent)
{
if (parent != null)
{
depth = parent.getDepth() + 1;
}
this.parent = parent;
return depth;
} | java |
public final void saveToFile(Media media)
{
try (FileWriting writing = new FileWriting(media))
{
saving(writing);
}
catch (final IOException exception)
{
throw new LionEngineException(exception, media, "Error on saving to file !");
}
} | java |
public final void loadFromFile(Media media)
{
try (FileReading reading = new FileReading(media))
{
loading(reading);
}
catch (final IOException exception)
{
throw new LionEngineException(exception, media, "Error on loading from file !");
}
... | java |
public void fill(Graphic g, ColorRgba color)
{
g.setColor(color);
g.drawRect(0, 0, source.getWidth(), source.getHeight(), true);
} | java |
public final <T extends InputDevice> T getInputDevice(Class<T> type)
{
return context.getInputDevice(type);
} | java |
public static LayerableConfig imports(Configurer configurer)
{
Check.notNull(configurer);
return imports(configurer.getRoot());
} | java |
public static LayerableConfig imports(Xml root)
{
Check.notNull(root);
final Xml node = root.getChild(NODE_LAYERABLE);
final int layerRefresh = node.readInteger(ATT_REFRESH);
final int layerDisplay = node.readInteger(ATT_DISPLAY);
return new LayerableConfig(layerRef... | java |
public static Xml exports(LayerableConfig config)
{
Check.notNull(config);
final Xml node = new Xml(NODE_LAYERABLE);
node.writeInteger(ATT_REFRESH, config.getLayerRefresh());
node.writeInteger(ATT_DISPLAY, config.getLayerDisplay());
return node;
} | java |
protected static int readInt(InputStream input, int bytesNumber, boolean bigEndian) throws IOException
{
final int oneByte = 8;
int ret = 0;
int sv;
if (bigEndian)
{
sv = (bytesNumber - 1) * oneByte;
}
else
{
sv = 0;
}
... | java |
protected static void checkSkippedError(long skipped, int instead) throws IOException
{
if (skipped != instead)
{
throw new IOException(MESSAGE_SKIPPED + skipped + MESSAGE_BYTES_INSTEAD_OF + instead);
}
} | java |
private static boolean checkHeader(InputStream input, int[] header) throws IOException
{
for (final int b : header)
{
if (b != input.read())
{
return false;
}
}
return true;
} | java |
private void update(CollisionCategory category)
{
final CollisionResult result = results.get(category.getName());
if (result != null
&& (result.getX() != null || result.getY() != null)
&& Boolean.TRUE.equals(enabledAxis.get(category.getAxis())))
{
... | java |
private void onCollided(CollisionResult result, CollisionCategory category)
{
for (final TileCollidableListener listener : listeners)
{
listener.notifyTileCollided(result, category);
}
} | java |
public static int multiplyRgb(int rgb, double fr, double fg, double fb)
{
if (rgb == 0)
{
return rgb;
}
final int a = rgb >> Constant.BYTE_4 & 0xFF;
final int r = (int) UtilMath.clamp((rgb >> Constant.BYTE_3 & 0xFF) * fr, 0, 255);
final int g = (... | java |
public static int inc(int value, int r, int g, int b)
{
final int alpha = value >> Constant.BYTE_4 & 0xFF;
if (alpha == 0)
{
return 0;
}
final int red = value >> Constant.BYTE_3 & 0xFF;
final int green = value >> Constant.BYTE_2 & 0xFF;
fi... | java |
public static double getDelta(ColorRgba a, ColorRgba b)
{
Check.notNull(a);
Check.notNull(b);
final int dr = a.getRed() - b.getRed();
final int dg = a.getGreen() - b.getGreen();
final int db = a.getBlue() - b.getBlue();
return Math.sqrt(dr * dr + dg * dg + ... | java |
public static ColorRgba getWeightedColor(ImageBuffer surface, int sx, int sy, int width, int height)
{
Check.notNull(surface);
int r = 0;
int g = 0;
int b = 0;
int count = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; ... | java |
private static Map<Transition, Collection<TileRef>> getTransitions(MapTile map)
{
final Map<Transition, Collection<TileRef>> transitions = new HashMap<>();
final MapTransitionExtractor extractor = new MapTransitionExtractor(map);
for (int ty = 1; ty < map.getInTileHeight() - 1; ty++)
... | java |
private static void checkTransition(Map<Transition, Collection<TileRef>> transitions,
MapTransitionExtractor extractor,
Tile tile)
{
final Transition transition = extractor.getTransition(tile);
if (transition != nul... | java |
private static Collection<TileRef> getTiles(Map<Transition, Collection<TileRef>> transitions, Transition transition)
{
if (!transitions.containsKey(transition))
{
transitions.put(transition, new HashSet<TileRef>());
}
return transitions.get(transition);
} | java |
public static double getRound(double speed, double value)
{
if (speed < 0)
{
return Math.floor(value);
}
return Math.ceil(value);
} | java |
public static boolean isBetween(double value, double min, double max)
{
return Double.compare(value, min) >= 0 && Double.compare(value, max) <= 0;
} | java |
public static double clamp(double value, double min, double max)
{
final double fixed;
if (value < min)
{
fixed = min;
}
else if (value > max)
{
fixed = max;
}
else
{
fixed = value;
}
return f... | java |
public static double curveValue(double value, double dest, double speed)
{
Check.different(speed, 0.0);
final double reciprocal = 1.0 / speed;
final double invReciprocal = 1.0 - reciprocal;
return value * invReciprocal + dest * reciprocal;
} | java |
public static double getDistance(double x1, double y1, double x2, double y2, int w2, int h2)
{
final double maxX = x2 + w2;
final double maxY = y2 + h2;
double min = getDistance(x1, y1, x2, y2);
for (double x = x2; Double.compare(x, maxX) <= 0; x++)
{
for (double... | java |
public static int getRounded(double value, int round)
{
Check.different(round, 0);
return (int) Math.floor(value / round) * round;
} | java |
public static int getRoundedC(double value, int round)
{
Check.different(round, 0);
return (int) Math.ceil(value / round) * round;
} | java |
public static Map<Transition, Collection<TileRef>> imports(Media config)
{
final Xml root = new Xml(config);
final Collection<Xml> nodesTransition = root.getChildren(NODE_TRANSITION);
final Map<Transition, Collection<TileRef>> transitions = new HashMap<>(nodesTransition.size());
... | java |
private static Collection<TileRef> importTiles(Collection<Xml> nodesTileRef)
{
final Collection<TileRef> tilesRef = new HashSet<>(nodesTileRef.size());
for (final Xml nodeTileRef : nodesTileRef)
{
final TileRef tileRef = TileConfig.imports(nodeTileRef);
tilesR... | java |
private static void exportTiles(Xml nodeTransition, Collection<TileRef> tilesRef)
{
for (final TileRef tileRef : tilesRef)
{
final Xml nodeTileRef = TileConfig.exports(tileRef);
nodeTransition.add(nodeTileRef);
}
} | java |
private void updateTile(Tile tile, Tile neighbor, Circuit circuit)
{
final Iterator<TileRef> iterator = getTiles(circuit).iterator();
while (iterator.hasNext())
{
final TileRef newTile = iterator.next();
if (mapGroup.getGroup(newTile).equals(mapGroup.getGroup(ti... | java |
private Circuit getCircuitOverTransition(Circuit circuit, Tile neighbor)
{
final String group = getTransitiveGroup(circuit, neighbor);
final Circuit newCircuit;
if (TileGroupType.TRANSITION == mapGroup.getType(circuit.getIn()))
{
newCircuit = new Circuit(circuit.get... | java |
private String getTransitiveGroup(Circuit initialCircuit, Tile tile)
{
final Set<Circuit> circuitSet = circuits.keySet();
final Collection<String> groups = new HashSet<>(circuitSet.size());
final String groupIn = mapGroup.getGroup(tile);
for (final Circuit circuit : circuitSet)
... | java |
private void computeRenderingPoint(int width, int height)
{
rx = (int) Math.floor(origin.getX(x, width));
ry = (int) Math.floor(origin.getY(y, height));
} | java |
public void changeState(Class<? extends State> next)
{
Check.notNull(next);
final State from = current;
if (current != null)
{
last = current.getClass();
current.exit();
}
if (!states.containsKey(next))
{
final ... | java |
public boolean isState(Class<? extends State> state)
{
if (current != null)
{
return current.getClass().equals(state);
}
return false;
} | java |
@SuppressWarnings("unchecked")
private State create(Class<? extends State> state)
{
try
{
if (configurer.isPresent())
{
final AnimationConfig configAnimations = AnimationConfig.imports(configurer.get());
final String name = converte... | java |
public void postUpdate()
{
if (current != null)
{
final Class<? extends State> next = current.checkTransitions(last);
if (next != null)
{
changeState(next);
}
}
} | java |
private void clearMenus()
{
for (final Featurable menu : menus)
{
menu.getFeature(Identifiable.class).destroy();
handler.remove(menu);
}
menus.clear();
} | java |
private void createMenus(Collection<ActionRef> parents, Collection<ActionRef> actions)
{
for (final ActionRef action : actions)
{
final Featurable menu = createMenu(action);
if (!action.getRefs().isEmpty())
{
generateSubMenu(actions, action,... | java |
private Featurable createMenu(ActionRef action)
{
final Featurable menu = factory.create(Medias.create(PATH.split(action.getPath())));
menus.add(menu);
return menu;
} | java |
private void generateSubMenu(final Collection<ActionRef> parents, final ActionRef action, Featurable menu)
{
menu.getFeature(Actionable.class).setAction(() ->
{
clearMenus();
createMenus(parents, action.getRefs());
});
} | java |
private void generateCancel(final ActionRef action, Featurable menu)
{
menu.getFeature(Actionable.class).setAction(() ->
{
clearMenus();
final Collection<ActionRef> parents = previous.get(action);
createMenus(parents, parents);
});
} | java |
private static void addFeatures(Featurable featurable, Services services, Setup setup)
{
final List<Feature> rawFeatures = FeaturableConfig.getFeatures(services, setup);
final int length = rawFeatures.size();
for (int i = 0; i < length; i++)
{
final Feature feature ... | java |
public Setup getSetup(Media media)
{
Check.notNull(media);
if (!setups.containsKey(media))
{
setups.put(media, createSetup(media));
}
return setups.get(media);
} | java |
@SuppressWarnings("unchecked")
private Setup createSetup(Media media)
{
final Configurer configurer = new Configurer(media);
try
{
final FeaturableConfig config = FeaturableConfig.imports(configurer);
final String setup = config.getSetupName();
... | java |
private <O extends Featurable> O createFeaturable(Class<O> type, Setup setup) throws NoSuchMethodException
{
final O featurable = UtilReflection.createReduce(type, services, setup);
addFeatures(featurable, services, setup);
for (final Feature feature : featurable.getFeatures())
... | java |
public static ImageHeader get(Media media)
{
Check.notNull(media);
for (final ImageHeaderReader reader : FORMATS)
{
if (reader.is(media))
{
return read(media, reader);
}
}
throw new LionEngineException(media, ERROR_READ);
... | java |
private static ImageHeader read(Media media, ImageHeaderReader reader)
{
Check.notNull(media);
Check.notNull(reader);
try (InputStream input = media.getInputStream())
{
return reader.readHeader(input);
}
catch (final IOException exception)
{
... | java |
public static CollisionGroupConfig imports(Xml root, MapTileCollision map)
{
Check.notNull(root);
Check.notNull(map);
final Collection<Xml> childrenCollision = root.getChildren(NODE_COLLISION);
final Map<String, CollisionGroup> groups = new HashMap<>(childrenCollision.size());... | java |
public static void exports(Xml root, CollisionGroup group)
{
Check.notNull(root);
Check.notNull(group);
final Xml node = root.createChild(NODE_COLLISION);
node.writeString(ATT_GROUP, group.getName());
for (final CollisionFormula formula : group.getFormulas())
... | java |
public static void remove(Xml root, String group)
{
Check.notNull(root);
Check.notNull(group);
for (final Xml node : root.getChildren(NODE_COLLISION))
{
if (node.readString(ATT_GROUP).equals(group))
{
root.removeChild(node);
... | java |
public static boolean has(Xml root, String group)
{
Check.notNull(root);
Check.notNull(group);
for (final Xml node : root.getChildren(NODE_COLLISION))
{
if (node.readString(ATT_GROUP).equals(group))
{
return true;
}
... | java |
public static TileSheetsConfig imports(Media configSheets)
{
final Xml nodeSheets = new Xml(configSheets);
final Xml nodeTileSize = nodeSheets.getChild(NODE_TILE_SIZE);
final int tileWidth = nodeTileSize.readInteger(ATT_TILE_WIDTH);
final int tileHeight = nodeTileSize.readInte... | java |
public static void exports(Media configSheets, int tileWidth, int tileHeight, Collection<String> sheets)
{
Check.notNull(configSheets);
Check.notNull(sheets);
final Xml nodeSheets = new Xml(NODE_TILE_SHEETS);
nodeSheets.writeString(Constant.XML_HEADER, Constant.ENGINE_WEBSITE)... | java |
private static Collection<String> importSheets(Xml nodeSheets)
{
final Collection<Xml> children = nodeSheets.getChildren(NODE_TILE_SHEET);
final Collection<String> sheets = new ArrayList<>(children.size());
for (final Xml nodeSheet : children)
{
final String sheet... | java |
private static void exportSheets(Xml nodeSheets, Collection<String> sheets)
{
for (final String sheet : sheets)
{
final Xml nodeSheet = nodeSheets.createChild(NODE_TILE_SHEET);
nodeSheet.setText(sheet);
}
} | java |
public static Force fromVector(double ox, double oy, double x, double y)
{
// Distance calculation
final double dh = x - ox;
final double dv = y - oy;
// Search vector and number of search steps
final double norm;
if (dh > dv)
{
norm = Math.abs(dh... | java |
public void addDirection(double extrp, Direction direction)
{
addDirection(extrp, direction.getDirectionHorizontal(), direction.getDirectionVertical());
} | java |
public void addDirection(double extrp, double fh, double fv)
{
fhLast = fh;
fvLast = fv;
this.fh += fh * extrp;
this.fv += fv * extrp;
fixForce();
} | java |
public void setDirection(double fh, double fv)
{
fhLast = fh;
fvLast = fv;
this.fh = fh;
this.fv = fv;
fixForce();
} | java |
private void updateLastForce()
{
if (Double.compare(fhLast, fhDest) != 0)
{
fhLast = fhDest;
arrivedH = false;
}
if (Double.compare(fvLast, fvDest) != 0)
{
fvLast = fvDest;
arrivedV = false;
}
} | java |
private void updateNotArrivedH(double extrp)
{
if (fh < fhDest)
{
fh += velocity * extrp;
if (fh > fhDest - sensibility)
{
fh = fhDest;
arrivedH = true;
}
}
else if (fh > fhDest)
{
fh ... | java |
private void updateNotArrivedV(double extrp)
{
if (fv < fvDest)
{
fv += velocity * extrp;
if (fv > fvDest - sensibility)
{
fv = fvDest;
arrivedV = true;
}
}
else if (fv > fvDest)
{
fv ... | java |
private void fixForce()
{
final double minH;
final double minV;
final double maxH;
final double maxV;
if (directionMin == null)
{
minH = fh;
minV = fv;
}
else
{
minH = directionMin.getDirectionHorizontal();
... | java |
public void loadCollisions(MapTileCollision mapCollision, Media collisionFormulas, Media collisionGroups)
{
if (collisionFormulas.exists())
{
loadCollisionFormulas(collisionFormulas);
}
if (collisionGroups.exists())
{
loadCollisionGroups(mapCol... | java |
public void loadCollisions(MapTileCollision mapCollision,
CollisionFormulaConfig formulasConfig,
CollisionGroupConfig groupsConfig)
{
loadCollisionFormulas(formulasConfig);
loadCollisionGroups(groupsConfig);
loadTilesCollisi... | java |
public CollisionFormula getCollisionFormula(String name)
{
if (formulas.containsKey(name))
{
return formulas.get(name);
}
throw new LionEngineException(ERROR_FORMULA + name);
} | java |
public CollisionGroup getCollisionGroup(String name)
{
if (groups.containsKey(name))
{
return groups.get(name);
}
throw new LionEngineException(ERROR_FORMULA + name);
} | java |
private void loadCollisionFormulas(Media formulasConfig)
{
Verbose.info(INFO_LOAD_FORMULAS, formulasConfig.getFile().getPath());
this.formulasConfig = formulasConfig;
final CollisionFormulaConfig config = CollisionFormulaConfig.imports(formulasConfig);
loadCollisionFormulas(conf... | java |
private void loadCollisionGroups(MapTileCollision mapCollision, Media groupsConfig)
{
Verbose.info(INFO_LOAD_GROUPS, groupsConfig.getFile().getPath());
this.groupsConfig = groupsConfig;
final Xml nodeGroups = new Xml(groupsConfig);
final CollisionGroupConfig config = Collision... | java |
private void loadTilesCollisions(MapTileCollision mapCollision)
{
for (int v = 0; v < map.getInTileHeight(); v++)
{
for (int h = 0; h < map.getInTileWidth(); h++)
{
final Tile tile = map.getTile(h, v);
if (tile != null)
... | java |
private void loadTileCollisions(MapTileCollision mapCollision, Tile tile)
{
final TileCollision tileCollision;
if (!tile.hasFeature(TileCollision.class))
{
tileCollision = new TileCollisionModel(tile);
tile.addFeature(tileCollision);
}
else
... | java |
private void addTileCollisions(MapTileCollision mapCollision, TileCollision tileCollision, Tile tile)
{
final TileRef ref = new TileRef(tile);
for (final CollisionGroup collision : mapCollision.getCollisionGroups())
{
final Collection<TileRef> group = mapGroup.getGroup(colli... | java |
private void applyConstraints()
{
final Map<Tile, Collection<CollisionFormula>> toRemove = new HashMap<>();
for (int v = 0; v < map.getInTileHeight(); v++)
{
for (int h = 0; h < map.getInTileWidth(); h++)
{
final Tile tile = map.getTile(h, v);
... | java |
private Collection<CollisionFormula> checkConstraints(TileCollision tile, int h, int v)
{
final Tile top = map.getTile(h, v + 1);
final Tile bottom = map.getTile(h, v - 1);
final Tile left = map.getTile(h - 1, v);
final Tile right = map.getTile(h + 1, v);
final Collec... | java |
private boolean checkConstraint(Collection<String> constraints, Tile tile)
{
return tile != null
&& constraints.contains(mapGroup.getGroup(tile))
&& !tile.getFeature(TileCollision.class).getCollisionFormulas().isEmpty();
} | java |
public void addPoint(double x, double y)
{
if (npoints >= xpoints.length)
{
final int newLength = npoints * 2;
xpoints = Arrays.copyOf(xpoints, newLength);
ypoints = Arrays.copyOf(ypoints, newLength);
}
xpoints[npoints] = x;
ypoint... | java |
public Collection<Line> getPoints()
{
final Collection<Line> list = new ArrayList<>(npoints);
for (int i = 0; i < npoints / 2; i++)
{
list.add(new Line(xpoints[i], ypoints[i], xpoints[i + npoints / 2], ypoints[i + npoints / 2]));
}
return list;
} | java |
private void updateBounds()
{
if (npoints >= MIN_POINTS)
{
double boundsMinX = Double.MAX_VALUE;
double boundsMinY = Double.MAX_VALUE;
double boundsMaxX = -Double.MAX_VALUE;
double boundsMaxY = -Double.MAX_VALUE;
for (int i = 0; i... | java |
public Resolution getScaled(double factorX, double factorY)
{
Check.superiorStrict(factorX, 0);
Check.superiorStrict(factorY, 0);
return new Resolution((int) (width * factorX), (int) (height * factorY), rate);
} | java |
public static TileRef imports(Xml nodeTile)
{
Check.notNull(nodeTile);
final int sheet = nodeTile.readInteger(ATT_TILE_SHEET);
final int number = nodeTile.readInteger(ATT_TILE_NUMBER);
return new TileRef(sheet, number);
} | java |
public static Xml exports(TileRef tileRef)
{
Check.notNull(tileRef);
final Xml node = new Xml(NODE_TILE);
node.writeInteger(ATT_TILE_SHEET, tileRef.getSheet().intValue());
node.writeInteger(ATT_TILE_NUMBER, tileRef.getNumber());
return node;
} | java |
public static SurfaceConfig imports(Configurer configurer)
{
Check.notNull(configurer);
return imports(configurer.getRoot());
} | java |
private static boolean checkPixel(MapTile map, ImageBuffer tileRef, int progressTileX, int progressTileY)
{
final int x = progressTileX * map.getTileWidth();
final int y = progressTileY * map.getTileHeight();
final int pixel = tileRef.getRgb(x, y);
// Skip blank tile of image map
... | java |
private static Tile searchForTile(MapTile map, ImageBuffer tileSprite, int x, int y)
{
// Check each tile on each sheet
for (final Integer sheet : map.getSheets())
{
final Tile tile = checkTile(map, tileSprite, sheet, x, y);
if (tile != null)
{
... | java |
private static Tile checkTile(MapTile map, ImageBuffer tileSprite, Integer sheet, int x, int y)
{
final int tw = map.getTileWidth();
final int th = map.getTileHeight();
final SpriteTiled tileSheet = map.getSheet(sheet);
final ImageBuffer sheetImage = tileSheet.getSurface();
f... | java |
private static StateUpdater createCheck(Cursor cursor, SelectorModel model, AtomicReference<StateUpdater> start)
{
return (extrp, current) ->
{
if (model.isEnabled() && cursor.getClick() == 0)
{
return start.get();
}
return current;
... | java |
private StateUpdater createStart(Cursor cursor, SelectorModel model, StateUpdater check, StateUpdater select)
{
return (extrp, current) ->
{
StateUpdater next = current;
if (!model.isEnabled())
{
next = check;
}
else if (mod... | java |
private void checkBeginSelection(Cursor cursor, SelectorModel model)
{
final boolean canClick = !model.getClickableArea().contains(cursor.getScreenX(), cursor.getScreenY());
if (!model.isSelecting() && !canClick)
{
model.setSelecting(true);
startX = cursor.getX();
... | java |
private void computeSelection(Viewer viewer, Cursor cursor, SelectorModel model)
{
final double viewX = viewer.getX() + viewer.getViewX();
final double viewY = viewer.getY() - viewer.getViewY();
final double currentX = UtilMath.clamp(cursor.getX(), viewX, viewX + viewer.getWidth());
... | java |
public static Map<Circuit, Collection<TileRef>> imports(Media circuitsConfig)
{
Check.notNull(circuitsConfig);
final Xml root = new Xml(circuitsConfig);
final Collection<Xml> nodesCircuit = root.getChildren(NODE_CIRCUIT);
final Map<Circuit, Collection<TileRef>> circuits = new ... | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.