conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
/* THREADING */
=======
/* VIEWING DISTANCE */
private static final int[] VIEWING_DISTANCES = {(Integer) SettingsManager.getInstance().getUserSetting("Game.Graphics.viewingDistanceNear"),
(Integer) SettingsManager.getInstance().getUserSetting("Game.Graphics.viewingDistanceModerate"),
(Integer) SettingsManager.getInstance().getUserSetting("Game.Graphics.viewingDistanceFar"),
(Integer) SettingsManager.getInstance().getUserSetting("Game.Graphics.viewingDistanceUltra")};
private int _activeViewingDistance = 0;
/* THREADING */
>>>>>>>
<<<<<<<
=======
// Generate a world with a random seed value
String worldSeed = (String) SettingsManager.getInstance().getWorldSetting("World.Creation.defaultSeed");
if (worldSeed.isEmpty())
worldSeed = null;
initWorld("World1", worldSeed);
initGroovy();
>>>>>>>
<<<<<<<
=======
/*
* Process mouse input - nothing system-y, so just passing it to the Player class
*/
private void processMouseInput() {
while (Mouse.next()) {
int button = Mouse.getEventButton();
int wheelMoved = Mouse.getEventDWheel();
for (UIDisplayElement screen : _guiScreens) {
if (screenCanFocus(screen)) {
screen.processMouseInput(button, Mouse.getEventButtonState(), wheelMoved);
}
}
if (!screenHasFocus())
_activeWorldRenderer.getPlayer().processMouseInput(button, Mouse.getEventButtonState(), wheelMoved);
}
}
/**
* Process keyboard input - first look for "system" like events, then otherwise pass to the Player object
*/
@SuppressWarnings("unchecked")
private void processKeyboardInput() {
boolean debugEnabled = (Boolean) SettingsManager.getInstance().getWorldSetting("World.Debug.debug");
while (Keyboard.next()) {
int key = Keyboard.getEventKey();
if (!Keyboard.isRepeatEvent() && Keyboard.getEventKeyState()) {
if (key == Keyboard.KEY_ESCAPE) {
togglePauseMenu();
}
if (key == Keyboard.KEY_I) {
toggleInventory();
}
if (key == Keyboard.KEY_F3) {
SettingsManager.getInstance().setWorldSetting("World.Debug.debug", debugEnabled = !(debugEnabled));
}
if (key == Keyboard.KEY_F) {
toggleViewingDistance();
}
// Pass input to focused GUI element
for (UIDisplayElement screen : _guiScreens) {
if (screenCanFocus(screen)) {
screen.processKeyboardInput(key);
}
}
}
// Features for debug mode only
if (debugEnabled) {
if (key == Keyboard.KEY_UP && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() + 0.005);
}
if (key == Keyboard.KEY_DOWN && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() - 0.005);
}
if (key == Keyboard.KEY_RIGHT && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() + 0.02);
}
if (key == Keyboard.KEY_LEFT && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() - 0.02);
}
}
// Pass input to the current player
if (!screenHasFocus())
_activeWorldRenderer.getPlayer().processKeyboardInput(key, Keyboard.getEventKeyState(), Keyboard.isRepeatEvent());
}
}
>>>>>>> |
<<<<<<<
return sequenceForPosition(ec, Long.MAX_VALUE, false);
=======
Sequence sequence1 = this.sequence;
if (sequence1 != null) {
for (int i = 0; i < 128; i++) {
long address = writePosition.getVolatileValue();
if (address == 0)
return -1;
long sequence = sequence1.getSequence(address);
if (sequence == Sequence.NOT_FOUND_RETRY)
continue;
if (sequence == Sequence.NOT_FOUND)
break;
return sequence;
}
}
return sequenceForPosition(recovery, ec, Long.MAX_VALUE, false);
>>>>>>>
Sequence sequence1 = this.sequence;
if (sequence1 != null) {
for (int i = 0; i < 128; i++) {
long address = writePosition.getVolatileValue();
if (address == 0)
return -1;
long sequence = sequence1.getSequence(address);
if (sequence == Sequence.NOT_FOUND_RETRY)
continue;
if (sequence == Sequence.NOT_FOUND)
break;
return sequence;
}
}
return sequenceForPosition(ec, Long.MAX_VALUE, false);
<<<<<<<
@SuppressWarnings("NullableProblems")
=======
long moveToEnd(final Wire wire) {
Sequence sequence1 = this.sequence;
if (sequence1 != null) {
for (int i = 0; i < 128; i++) {
long endAddress = writePosition.getVolatileValue();
if (endAddress == 0)
return -1;
long sequence = sequence1.getSequence(endAddress);
if (sequence == Sequence.NOT_FOUND_RETRY)
continue;
if (sequence == Sequence.NOT_FOUND)
return -1;
Bytes<?> bytes = wire.bytes();
bytes.readPosition(endAddress);
for (; ; ) {
int header = bytes.readInt(endAddress);
if (header == 0 || Wires.isNotComplete(header))
return sequence;
int len = Wires.lengthOf(header) + 4;
bytes.readSkip(len);
endAddress += len;
if (Wires.isData(header))
sequence += 1;
}
}
}
return -1;
}
>>>>>>>
long moveToEnd(final Wire wire) {
Sequence sequence1 = this.sequence;
if (sequence1 != null) {
for (int i = 0; i < 128; i++) {
long endAddress = writePosition.getVolatileValue();
if (endAddress == 0)
return -1;
long sequence = sequence1.getSequence(endAddress);
if (sequence == Sequence.NOT_FOUND_RETRY)
continue;
if (sequence == Sequence.NOT_FOUND)
return -1;
Bytes<?> bytes = wire.bytes();
bytes.readPosition(endAddress);
for (; ; ) {
int header = bytes.readInt(endAddress);
if (header == 0 || Wires.isNotComplete(header))
return sequence;
int len = Wires.lengthOf(header) + 4;
bytes.readSkip(len);
endAddress += len;
if (Wires.isData(header))
sequence += 1;
}
}
}
return -1;
} |
<<<<<<<
import org.terasology.asset.AssetManager;
import org.terasology.asset.AssetType;
import org.terasology.asset.AssetUri;
=======
>>>>>>>
<<<<<<<
import org.terasology.context.Context;
=======
import org.terasology.assets.ResourceUrn;
>>>>>>>
import org.terasology.assets.ResourceUrn;
import org.terasology.context.Context;
<<<<<<<
private Mesh billboard;
=======
private Mesh billboard = Assets.getMesh("engine:UIBillboard").get();
>>>>>>>
private Mesh billboard;
<<<<<<<
private Material textureMat;
=======
private Material textureMat = Assets.getMaterial("engine:UITexture").get();
>>>>>>>
private Material textureMat; |
<<<<<<<
import org.terasology.asset.AssetManager;
import org.terasology.asset.AssetType;
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
=======
import org.terasology.assets.management.AssetManager;
>>>>>>>
import org.terasology.assets.management.AssetManager;
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
<<<<<<<
Context context = new ContextImpl();
context.put(ModuleManager.class, moduleManager);
AssetManager assetManager = mock(AssetManager.class);
context.put(AssetManager.class,assetManager);
CoreRegistry.setContext(context);
when(assetManager.listLoadedAssets(AssetType.PREFAB, Prefab.class)).thenReturn(Collections.<Prefab>emptyList());
EntitySystemSetupUtil.addReflectionBasedLibraries(context);
EntitySystemSetupUtil.addEntityManagementRelatedClasses(context);
entityManager = context.get(EngineEntityManager.class);
=======
AssetManager assetManager = CoreRegistry.put(AssetManager.class, mock(AssetManager.class));
EntitySystemBuilder builder = new EntitySystemBuilder();
entityManager = builder.build(moduleManager.getEnvironment(), mock(NetworkSystem.class), new ReflectionReflectFactory());
>>>>>>>
Context context = new ContextImpl();
context.put(ModuleManager.class, moduleManager);
AssetManager assetManager = mock(AssetManager.class);
context.put(AssetManager.class,assetManager);
CoreRegistry.setContext(context);
EntitySystemSetupUtil.addReflectionBasedLibraries(context);
EntitySystemSetupUtil.addEntityManagementRelatedClasses(context);
entityManager = context.get(EngineEntityManager.class); |
<<<<<<<
import javax.vecmath.Vector3f;
import java.io.InputStream;
=======
>>>>>>>
import javax.vecmath.Vector3f; |
<<<<<<<
import org.newdawn.slick.openal.SoundStore;
import org.terasology.entitySystem.EntityManager;
=======
>>>>>>>
import org.terasology.entitySystem.EntityManager; |
<<<<<<<
import com.google.common.collect.MapMaker;
import com.google.common.collect.Sets;
=======
import com.google.common.collect.Lists;
import com.google.common.collect.MapMaker;
>>>>>>>
import com.google.common.collect.Lists;
import com.google.common.collect.MapMaker;
import com.google.common.collect.Sets;
<<<<<<<
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.vecmath.Quat4f;
import javax.vecmath.Vector3f;
=======
>>>>>>>
<<<<<<<
private Map<Integer, EntityRef> entityCache = new MapMaker().concurrencyLevel(4).weakValues().makeMap();
private Set<EntityChangeSubscriber> subscribers = Sets.newLinkedHashSet();
=======
private Map<Integer, EntityRef> entityCache = new MapMaker().concurrencyLevel(4).weakValues().makeMap();
>>>>>>>
private Map<Integer, EntityRef> entityCache = new MapMaker().concurrencyLevel(4).weakValues().makeMap();
private Set<EntityChangeSubscriber> subscribers = Sets.newLinkedHashSet();
<<<<<<<
private void notifyComponentAdded(EntityRef changedEntity, Class<? extends Component> component) {
for (EntityChangeSubscriber subscriber : subscribers) {
subscriber.onEntityComponentAdded(changedEntity, component);
}
}
private void notifyComponentRemoved(EntityRef changedEntity, Class<? extends Component> component) {
for (EntityChangeSubscriber subscriber : subscribers) {
subscriber.onEntityComponentRemoved(changedEntity, component);
}
}
private void notifyComponentChanged(EntityRef changedEntity, Class<? extends Component> component) {
for (EntityChangeSubscriber subscriber : subscribers) {
subscriber.onEntityComponentChange(changedEntity, component);
}
}
=======
public int getActiveEntities() {
return entityCache.size();
}
>>>>>>>
private void notifyComponentAdded(EntityRef changedEntity, Class<? extends Component> component) {
for (EntityChangeSubscriber subscriber : subscribers) {
subscriber.onEntityComponentAdded(changedEntity, component);
}
}
private void notifyComponentRemoved(EntityRef changedEntity, Class<? extends Component> component) {
for (EntityChangeSubscriber subscriber : subscribers) {
subscriber.onEntityComponentRemoved(changedEntity, component);
}
}
private void notifyComponentChanged(EntityRef changedEntity, Class<? extends Component> component) {
for (EntityChangeSubscriber subscriber : subscribers) {
subscriber.onEntityComponentChange(changedEntity, component);
}
}
public int getActiveEntities() {
return entityCache.size();
} |
<<<<<<<
=======
private static String getNewTitle(String title) {
String newTitle = title.substring(0, getPositionOfLastDigit(title));
int fileNumber = getLastNumber(title);
fileNumber++;
return (newTitle + " " + fileNumber);
}
private static SplashScreen configureSplashScreen() {
int imageHeight = 283;
int maxTextWidth = 450;
int width = 600;
int height = 30;
int left = 20;
int top = imageHeight - height - 20;
Rectangle rectRc = new Rectangle(left, top, width, height);
Rectangle textRc = new Rectangle(left + 10, top + 5, maxTextWidth, height);
Rectangle boxRc = new Rectangle(left + maxTextWidth + 10, top, width - maxTextWidth - 20, height);
SplashScreenBuilder builder = new SplashScreenBuilder();
String[] imgFiles = new String[] {
"splash_1.png",
"splash_2.png",
"splash_3.png",
"splash_4.png",
"splash_5.png"
};
Point[] imgOffsets = new Point[] {
new Point(0, 0),
new Point(150, 0),
new Point(300, 0),
new Point(450, 0),
new Point(630, 0)
};
EngineStatus[] trigger = new EngineStatus[] {
TerasologyEngineStatus.PREPARING_SUBSYSTEMS,
TerasologyEngineStatus.INITIALIZING_MODULE_MANAGER,
TerasologyEngineStatus.INITIALIZING_ASSET_TYPES,
TerasologyEngineStatus.INITIALIZING_SUBSYSTEMS,
TerasologyEngineStatus.INITIALIZING_ASSET_MANAGEMENT,
};
try {
for (int index = 0; index < 5; index++) {
URL resource = Terasology.class.getResource("/splash/" + imgFiles[index]);
builder.add(new TriggerImageOverlay(verifyNotNull(resource, "resource /splash/%s", imgFiles[index]))
.setTrigger(trigger[index].getDescription())
.setPosition(imgOffsets[index].x, imgOffsets[index].y));
}
builder.add(new ImageOverlay(Terasology.class.getResource("/splash/splash_text.png")));
} catch (IOException e) {
e.printStackTrace();
}
SplashScreen instance = builder
.add(new RectOverlay(rectRc))
.add(new TextOverlay(textRc))
.add(new AnimatedBoxRowOverlay(boxRc))
.build();
return instance;
}
>>>>>>>
private static String getNewTitle(String title) {
String newTitle = title.substring(0, getPositionOfLastDigit(title));
int fileNumber = getLastNumber(title);
fileNumber++;
return (newTitle + " " + fileNumber);
} |
<<<<<<<
=======
import javax.vecmath.Vector3f;
import org.terasology.componentSystem.block.BlockEntityRegistry;
>>>>>>>
<<<<<<<
worldProvider.setBlock(blockPos, BlockManager.getInstance().getAir(), currentBlock);
=======
worldProvider.setBlock(blockPos, (byte)0x0, true, true);
>>>>>>>
worldProvider.setBlock(blockPos, BlockManager.getInstance().getAir(), currentBlock); |
<<<<<<<
double noise = _noiseGenerator.fBm(i * 0.05, j * 0.05, _parent.getWorldProvider().getTimeInDays());
=======
double noise = _noiseGenerator.fBm(i * 0.008, j * 0.008, _parent.getWorldProvider().getTime());
>>>>>>>
double noise = _noiseGenerator.fBm(i * 0.008, j * 0.008, _parent.getWorldProvider().getTimeInDays()); |
<<<<<<<
import com.google.common.collect.Lists;
=======
import static org.lwjgl.opengl.GL11.GL_BLEND;
import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_FILL;
import static org.lwjgl.opengl.GL11.GL_FRONT_AND_BACK;
import static org.lwjgl.opengl.GL11.GL_LIGHT0;
import static org.lwjgl.opengl.GL11.GL_LINE;
import static org.lwjgl.opengl.GL11.GL_ONE_MINUS_SRC_ALPHA;
import static org.lwjgl.opengl.GL11.GL_SRC_ALPHA;
import static org.lwjgl.opengl.GL11.glBlendFunc;
import static org.lwjgl.opengl.GL11.glClear;
import static org.lwjgl.opengl.GL11.glColorMask;
import static org.lwjgl.opengl.GL11.glCullFace;
import static org.lwjgl.opengl.GL11.glDisable;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL11.glLoadIdentity;
import static org.lwjgl.opengl.GL11.glPolygonMode;
import static org.lwjgl.opengl.GL11.glPopMatrix;
import static org.lwjgl.opengl.GL11.glPushMatrix;
import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import javax.imageio.ImageIO;
import javax.vecmath.Vector3f;
>>>>>>>
import com.google.common.collect.Lists;
<<<<<<<
=======
import org.terasology.world.chunks.ChunkStore;
import org.terasology.world.chunks.LocalChunkProvider;
import org.terasology.world.chunks.store.ChunkStoreGZip;
import org.terasology.world.chunks.store.ChunkStoreProtobuf;
import org.terasology.world.generator.core.ChunkGeneratorManager;
>>>>>>>
import org.terasology.world.chunks.ChunkStore;
import org.terasology.world.chunks.store.ChunkStoreGZip;
import org.terasology.world.chunks.store.ChunkStoreProtobuf;
<<<<<<<
private ComponentSystemManager systemManager;
=======
private ComponentSystemManager _systemManager;
private ChunkStore loadChunkStore(File file) throws IOException {
FileInputStream fileIn = null;
ObjectInputStream in = null;
try {
fileIn = new FileInputStream(file);
in = new ObjectInputStream(fileIn);
ChunkStore cache = (ChunkStore) in.readObject();
if (cache instanceof ChunkStoreGZip) {
((ChunkStoreGZip) cache).setup();
logger.info("Using old chunk store implementation without protobuf support for compatibility.");
} else if (cache instanceof ChunkStoreProtobuf)
((ChunkStoreProtobuf) cache).setup();
else
logger.warn("Chunk store might not have been initialized: {}", cache.getClass().getName());
return cache;
} catch (ClassNotFoundException e) {
throw new IOException("Unable to load chunk cache", e);
} finally {
// JAVA7 : cleanup
if (in != null) {
try {
in.close();
} catch (IOException e) {
logger.error("Failed to close input stream", e);
}
}
if (fileIn != null) {
try {
fileIn.close();
} catch (IOException e) {
logger.error("Failed to close input stream", e);
}
}
}
}
>>>>>>>
private ComponentSystemManager systemManager;
<<<<<<<
public WorldRenderer(WorldInfo worldInfo, ChunkProvider chunkProvider, LocalPlayerSystem localPlayerSystem) {
this.chunkProvider = chunkProvider;
EntityAwareWorldProvider entityWorldProvider = new EntityAwareWorldProvider(new WorldProviderCoreImpl(worldInfo, this.chunkProvider));
=======
public WorldRenderer(WorldInfo worldInfo, ChunkGeneratorManager chunkGeneratorManager, EntityManager manager, LocalPlayerSystem localPlayerSystem) {
// TODO: Cleaner method for this? Should not be using the world title
File f = new File(PathManager.getInstance().getWorldSavePath(worldInfo.getTitle()), worldInfo.getTitle() + ".dat");
if (f.exists()) {
try {
chunkStore = loadChunkStore(f);
} catch (IOException e) {
/* TODO: We really should expose this error via UI so player knows that there is an issue with their world
(don't have the game continue or we risk overwriting their game)
*/
e.printStackTrace();
}
}
if (chunkStore == null) {
chunkStore = new ChunkStoreProtobuf();
}
_chunkProvider = new LocalChunkProvider(chunkStore, chunkGeneratorManager);
EntityAwareWorldProvider entityWorldProvider = new EntityAwareWorldProvider(new WorldProviderCoreImpl(worldInfo, _chunkProvider));
>>>>>>>
public WorldRenderer(WorldInfo worldInfo, ChunkProvider chunkProvider, LocalPlayerSystem localPlayerSystem) {
this.chunkProvider = chunkProvider;
EntityAwareWorldProvider entityWorldProvider = new EntityAwareWorldProvider(new WorldProviderCoreImpl(worldInfo, this.chunkProvider));
<<<<<<<
//TODO get beter tck instead afternoon
if (getPlayerPosition().y < 50)
AudioManager.playMusic("engine:DwarfForge");
else if (getPlayerPosition().y > 175)
AudioManager.playMusic("engine:SpaceExplorers");
else
AudioManager.playMusic("engine:Afternoon");
=======
if(getPlayerPosition().y<50)
AudioManager.playMusic("engine:DwarfForge");
else if(getPlayerPosition().y>175)
AudioManager.playMusic("engine:SpaceExplorers");
else
AudioManager.playMusic("engine:Afternoon");
>>>>>>>
//TODO get beter tck instead afternoon
if (getPlayerPosition().y < 50)
AudioManager.playMusic("engine:DwarfForge");
else if (getPlayerPosition().y > 175)
AudioManager.playMusic("engine:SpaceExplorers");
else
AudioManager.playMusic("engine:Afternoon");
<<<<<<<
activeCamera.loadProjectionMatrix(80f);
=======
_activeCamera.loadProjectionMatrix(90f);
>>>>>>>
activeCamera.loadProjectionMatrix(90f);
<<<<<<<
boolean headUnderWater;
headUnderWater = cameraMode == CAMERA_MODE.PLAYER && isUnderwater();
=======
boolean headUnderWater =_cameraMode == CAMERA_MODE.PLAYER && isUnderWater();
>>>>>>>
boolean headUnderWater = cameraMode == CAMERA_MODE.PLAYER && isUnderWater();
<<<<<<<
for (RenderSystem renderer : systemManager.iterateRenderSubscribers()) {
=======
PerformanceMonitor.endActivity();
PerformanceMonitor.startActivity("Render Overlays");
for (RenderSystem renderer : _systemManager.iterateRenderSubscribers()) {
>>>>>>>
PerformanceMonitor.endActivity();
PerformanceMonitor.startActivity("Render Overlays");
for (RenderSystem renderer : systemManager.iterateRenderSubscribers()) {
<<<<<<<
for (Chunk c : renderQueueChunksOpaque)
renderChunk(c, ChunkMesh.RENDER_PHASE.OPAQUE, camera);
=======
for (Chunk c : _renderQueueChunksOpaque)
renderChunk(c, ChunkMesh.RENDER_PHASE.OPAQUE, camera);
>>>>>>>
for (Chunk c : renderQueueChunksOpaque) {
renderChunk(c, ChunkMesh.RENDER_PHASE.OPAQUE, camera);
}
<<<<<<<
for (Chunk c : renderQueueChunksSortedBillboards)
renderChunk(c, ChunkMesh.RENDER_PHASE.BILLBOARD_AND_TRANSLUCENT, camera);
=======
for (Chunk c : _renderQueueChunksSortedBillboards)
renderChunk(c, ChunkMesh.RENDER_PHASE.BILLBOARD_AND_TRANSLUCENT, camera);
>>>>>>>
for (Chunk c : renderQueueChunksSortedBillboards) {
renderChunk(c, ChunkMesh.RENDER_PHASE.BILLBOARD_AND_TRANSLUCENT, camera);
}
<<<<<<<
float lightValueSun = worldProvider.getSunlight(pos);
lightValueSun /= 15.0f;
=======
float lightValueSun = (float) Math.pow(0.76, 16 - _worldProvider.getSunlight(pos));
>>>>>>>
float lightValueSun = (float) Math.pow(0.76, 16 - worldProvider.getSunlight(pos));
<<<<<<<
float lightValueBlock = worldProvider.getLight(pos);
lightValueBlock /= 15f;
=======
float lightValueBlock = (float) Math.pow(0.76, 16 - _worldProvider.getLight(pos));
>>>>>>>
float lightValueBlock = (float) Math.pow(0.76, 16 - worldProvider.getLight(pos)); |
<<<<<<<
import net.openhft.chronicle.Chronicle;
import net.openhft.chronicle.ChronicleQueueBuilder;
import net.openhft.chronicle.Excerpt;
import net.openhft.chronicle.ExcerptAppender;
import net.openhft.chronicle.ExcerptCommon;
import net.openhft.chronicle.ExcerptComparator;
import net.openhft.chronicle.ExcerptTailer;
import net.openhft.chronicle.IndexedChronicle;
import net.openhft.chronicle.VanillaChronicle;
import net.openhft.chronicle.tools.WrappedChronicle;
=======
import net.openhft.chronicle.*;
>>>>>>>
import net.openhft.chronicle.Chronicle;
import net.openhft.chronicle.ChronicleQueueBuilder;
import net.openhft.chronicle.Excerpt;
import net.openhft.chronicle.ExcerptAppender;
import net.openhft.chronicle.ExcerptCommon;
import net.openhft.chronicle.ExcerptComparator;
import net.openhft.chronicle.ExcerptTailer;
import net.openhft.chronicle.IndexedChronicle;
import net.openhft.chronicle.VanillaChronicle;
import net.openhft.chronicle.tools.WrappedChronicle;
<<<<<<<
private final SinkTcp connection;
private final ChronicleQueueBuilder.ReplicaChronicleQueueBuilder builder;
=======
private final Logger logger;
>>>>>>>
private final SinkTcp connection;
private final ChronicleQueueBuilder.ReplicaChronicleQueueBuilder builder;
<<<<<<<
private volatile boolean closed;
private ExcerptCommon excerpt;
public ChronicleSink(final ChronicleQueueBuilder.ReplicaChronicleQueueBuilder builder, final SinkTcp connection) {
super(builder.chronicle());
this.connection = connection;
this.builder = builder;
this.closed = false;
this.isLocal = builder.sharedChronicle() && connection.isLocalhost();
this.excerpt = null;
=======
private volatile boolean closed = false;
public ChronicleSink(String hostname, int port) throws IOException {
this(null, ChronicleSinkConfig.DEFAULT, new InetSocketAddress(hostname, port));
}
public ChronicleSink(@NotNull Chronicle chronicle, String hostname, int port) throws IOException {
this(chronicle, ChronicleSinkConfig.DEFAULT, new InetSocketAddress(hostname, port));
}
public ChronicleSink(@NotNull Chronicle chronicle, @NotNull final ChronicleSinkConfig config, String hostname, int port) throws IOException {
this(chronicle, config, new InetSocketAddress(hostname, port));
}
public ChronicleSink(@NotNull final ChronicleSinkConfig config, String hostname, int port) throws IOException {
this(null, config, new InetSocketAddress(hostname, port));
}
public ChronicleSink(@NotNull final InetSocketAddress address) throws IOException {
this(null, ChronicleSinkConfig.DEFAULT, address);
}
public ChronicleSink(@NotNull final Chronicle chronicle, @NotNull final InetSocketAddress address) throws IOException {
this(chronicle, ChronicleSinkConfig.DEFAULT, address);
}
public ChronicleSink(@NotNull final ChronicleSinkConfig config, @NotNull final InetSocketAddress address) throws IOException {
this(null, config, address);
}
public ChronicleSink(@NotNull final Chronicle chronicle, @NotNull final ChronicleSinkConfig config, @NotNull final InetSocketAddress address) throws IOException {
this.chronicle = chronicle;
this.config = config;
this.address = address;
this.logger = LoggerFactory.getLogger(getClass().getName() + '.' + address.getHostName() + '@' + address.getPort());
this.excerpts = Collections.synchronizedList(new LinkedList<ExcerptCommon>());
this.isLocal = config.sharedChronicle() && ChronicleTcp.isLocalhost(this.address.getAddress());
}
@Override
public String name() {
return chronicle.name();
>>>>>>>
private volatile boolean closed;
private ExcerptCommon excerpt;
public ChronicleSink(final ChronicleQueueBuilder.ReplicaChronicleQueueBuilder builder, final SinkTcp connection) {
super(builder.chronicle());
this.connection = connection;
this.builder = builder;
this.closed = false;
this.isLocal = builder.sharedChronicle() && connection.isLocalhost();
this.excerpt = null;
<<<<<<<
private final ByteBuffer writeBuffer;
private final ByteBuffer readBuffer;
private long index;
private int lastSize;
=======
private final ByteBuffer buffer;
private final SinkConnector connector;
private long index;
private int lastSize;
>>>>>>>
private final ByteBuffer writeBuffer;
private final ByteBuffer readBuffer;
private long index;
private int lastSize;
<<<<<<<
this.logger = LoggerFactory.getLogger(getClass().getName() + "@" + connection.toString());
this.writeBuffer = ChronicleTcp.createBufferOfSize(16);
this.readBuffer = ChronicleTcp.createBuffer(builder.minBufferSize());
this.startAddr = ((DirectBuffer) this.readBuffer).address();
this.capacityAddr = this.startAddr + builder.minBufferSize();
=======
this.logger = LoggerFactory.getLogger(getClass().getName() + "@" + address.toString());
this.connector = new SinkConnector();
this.buffer = this.connector.buffer();
this.startAddr = ((DirectBuffer) this.buffer).address();
this.capacityAddr = this.startAddr + config.minBufferSize();
this.finished = true;
>>>>>>>
this.logger = LoggerFactory.getLogger(getClass().getName() + "@" + connection.toString());
this.writeBuffer = ChronicleTcp.createBufferOfSize(16);
this.readBuffer = ChronicleTcp.createBuffer(builder.minBufferSize());
this.startAddr = ((DirectBuffer) this.readBuffer).address();
this.capacityAddr = this.startAddr + builder.minBufferSize();
this.finished = true; |
<<<<<<<
import org.terasology.rendering.dag.nodes.CopyImageToScreenNode;
import org.terasology.rendering.openvrprovider.OpenVRProvider;
import org.lwjgl.opengl.GL11;
=======
>>>>>>>
import org.terasology.rendering.dag.nodes.CopyImageToScreenNode;
import org.terasology.rendering.openvrprovider.OpenVRProvider; |
<<<<<<<
this.entityManager = CoreRegistry.get(EntityManager.class);
this.worldProvider = CoreRegistry.get(WorldProvider.class);
this.effectsTexture = AssetManager.loadTexture("engine:effects");
=======
entityManager = CoreRegistry.get(EntityManager.class);
worldProvider = CoreRegistry.get(IWorldProvider.class);
effectsTexture = AssetManager.loadTexture("engine:effects");
>>>>>>>
this.entityManager = CoreRegistry.get(EntityManager.class);
this.worldProvider = CoreRegistry.get(WorldProvider.class);
this.effectsTexture = AssetManager.loadTexture("engine:effects");
<<<<<<<
@Override
public void shutdown() {
}
=======
@Override
>>>>>>>
@Override
public void shutdown() {
}
@Override |
<<<<<<<
public class UIHeadsUpDisplay extends UIDisplayWindow {
=======
public class UIHeadsUpDisplay extends UIDisplayRenderer implements EventHandlerSystem {
protected EntityManager entityManager;
>>>>>>>
public class UIHeadsUpDisplay extends UIDisplayWindow implements EventHandlerSystem {
protected EntityManager entityManager;
<<<<<<<
=======
@Override
public void processKeyboardInput(int key) {
super.processKeyboardInput(key);
if (!isVisible())
return;
if (key == Keyboard.KEY_TAB) {
_console.setVisible(!_console.isVisible());
}
}
public UIDebugConsole getDebugConsole() {
return _console;
}
@Override
public void initialise() {
entityManager = CoreRegistry.get(EntityManager.class);
}
@ReceiveEvent(components = {MinionComponent.class})
public void onMessageReceived(MinionMessageEvent event, EntityRef entityref) {
_messagequeue.addIconToQueue(event.getMinionMessage());
}
>>>>>>>
@Override
public void initialise() {
entityManager = CoreRegistry.get(EntityManager.class);
}
@ReceiveEvent(components = {MinionComponent.class})
public void onMessageReceived(MinionMessageEvent event, EntityRef entityref) {
_messagequeue.addIconToQueue(event.getMinionMessage());
} |
<<<<<<<
import org.terasology.logic.characters.events.DeathEvent;
import org.terasology.logic.health.DamageEvent;
=======
import org.terasology.game.CoreRegistry;
>>>>>>>
import org.terasology.game.CoreRegistry;
<<<<<<<
import org.terasology.logic.health.NoHealthEvent;
=======
import org.terasology.logic.health.DamageEvent;
import org.terasology.logic.inventory.InventoryManager;
>>>>>>>
import org.terasology.logic.health.DamageEvent;
import org.terasology.logic.health.NoHealthEvent;
import org.terasology.logic.inventory.InventoryManager; |
<<<<<<<
import com.google.common.collect.Lists;
import org.terasology.logic.world.BlockUpdate;
import org.terasology.logic.world.WorldProvider;
import org.terasology.model.blocks.Block;
=======
>>>>>>>
import com.google.common.collect.Lists;
import org.terasology.logic.world.BlockUpdate;
import org.terasology.logic.world.WorldProvider;
import org.terasology.model.blocks.Block; |
<<<<<<<
import org.terasology.context.Context;
import org.terasology.engine.SimpleUri;
import org.terasology.engine.module.ModuleManager;
import org.terasology.engine.paths.PathManager;
=======
import org.terasology.engine.context.Context;
import org.terasology.engine.core.SimpleUri;
import org.terasology.engine.core.TerasologyConstants;
import org.terasology.engine.core.module.ModuleManager;
import org.terasology.engine.core.paths.PathManager;
import org.terasology.engine.registry.InjectionHelper;
import org.terasology.engine.utilities.ReflectionUtil;
>>>>>>>
import org.terasology.engine.context.Context;
import org.terasology.engine.core.SimpleUri;
import org.terasology.engine.core.module.ModuleManager;
import org.terasology.engine.core.paths.PathManager;
import org.terasology.engine.registry.InjectionHelper;
import org.terasology.engine.utilities.ReflectionUtil;
<<<<<<<
import org.terasology.persistence.serializers.Serializer;
import org.terasology.reflection.TypeInfo;
import org.terasology.registry.InjectionHelper;
import org.terasology.utilities.ReflectionUtil;
=======
import org.terasology.persistence.typeHandling.TypeHandlerLibrary;
>>>>>>>
import org.terasology.persistence.serializers.Serializer;
import org.terasology.reflection.TypeInfo; |
<<<<<<<
return String.format("world (biome: %s, time: %.2f, exposure: %.2f, sun: %.2f, cache: %d, dirty: %d, ign: %d, vis: %d, tri: %d, empty: %d, !ready: %d, seed: \"%s\", title: \"%s\")", getPlayerBiome(), _worldProvider.getTime(), PostProcessingRenderer.getInstance().getExposure(), _skysphere.getSunPosAngle(), _worldProvider.getChunkProvider().size(), _statDirtyChunks, _statIgnoredPhases, _statVisibleChunks, Chunk._statRenderedTriangles, Chunk._statChunkMeshEmpty, Chunk._statChunkNotReady, _worldProvider.getSeed(), _worldProvider.getTitle());
=======
return String.format("world (biome: %s, time: %.2f, exposure: %.2f, sun: %.2f, cache: %fMb, dirty: %d, ign: %d, vis: %d, tri: %d, empty: %d, !ready: %d, seed: \"%s\", title: \"%s\")", getActiveBiome(), _worldProvider.getTime(), PostProcessingRenderer.getInstance().getExposure(), _skysphere.getSunPosAngle(), _worldProvider.getChunkProvider().size(), _statDirtyChunks, _statIgnoredPhases, _statVisibleChunks, Chunk._statRenderedTriangles, Chunk._statChunkMeshEmpty, Chunk._statChunkNotReady, _worldProvider.getSeed(), _worldProvider.getTitle());
>>>>>>>
return String.format("world (biome: %s, time: %.2f, exposure: %.2f, sun: %.2f, cache: %fMb, dirty: %d, ign: %d, vis: %d, tri: %d, empty: %d, !ready: %d, seed: \"%s\", title: \"%s\")", getPlayerBiome(), _worldProvider.getTime(), PostProcessingRenderer.getInstance().getExposure(), _skysphere.getSunPosAngle(), _worldProvider.getChunkProvider().size(), _statDirtyChunks, _statIgnoredPhases, _statVisibleChunks, Chunk._statRenderedTriangles, Chunk._statChunkMeshEmpty, Chunk._statChunkNotReady, _worldProvider.getSeed(), _worldProvider.getTitle()); |
<<<<<<<
final UIButton _exitButton;
final UIButton _optionsButton;
final UIButton _startButton;
=======
private final UIButton _exitButton;
private final UIButton _startButton;
private final UIButton _configButton;
>>>>>>>
private final UIButton _exitButton;
final UIButton _optionsButton;
private final UIButton _startButton;
private final UIButton _configButton;
<<<<<<<
_optionsButton = new UIButton(new Vector2f(256f, 32f));
_optionsButton.getLabel().setText("Select World");
_optionsButton.setVisible(true);
_optionsButton.addClickListener(new IClickListener() {
public void clicked(UIDisplayElement element) {
Terasology.getInstance().getGameMode().deactivateScreen("main_menu");
Terasology.getInstance().getGameMode().activateScreen("select_world");
}
});
_exitButton.addClickListener(new IClickListener() {
public void clicked(UIDisplayElement element) {
Terasology.getInstance().exit();
}
});
=======
_configButton = new UIButton(new Vector2f(256f, 32f));
_configButton.getLabel().setText("Settings");
_configButton.setVisible(true);
>>>>>>>
_optionsButton = new UIButton(new Vector2f(256f, 32f));
_optionsButton.getLabel().setText("Select World");
_optionsButton.setVisible(true);
_optionsButton.addClickListener(new IClickListener() {
public void clicked(UIDisplayElement element) {
Terasology.getInstance().getGameMode().deactivateScreen("main_menu");
Terasology.getInstance().getGameMode().activateScreen("select_world");
}
});
_exitButton.addClickListener(new IClickListener() {
public void clicked(UIDisplayElement element) {
Terasology.getInstance().exit();
}
});
_configButton = new UIButton(new Vector2f(256f, 32f));
_configButton.getLabel().setText("Settings");
_configButton.setVisible(true);
<<<<<<<
addDisplayElement(_optionsButton);
=======
addDisplayElement(_configButton);
>>>>>>>
addDisplayElement(_optionsButton);
addDisplayElement(_configButton);
<<<<<<<
_optionsButton.centerHorizontally();
_optionsButton.getPosition().y = 300f + 2 * 32f + 32f;
_exitButton.centerHorizontally();
_exitButton.getPosition().y = 300f + 3 * 32f + 64f;
=======
_configButton.centerHorizontally();
_configButton.getPosition().y = 300f + 2 * 40f;
>>>>>>>
_optionsButton.centerHorizontally();
_optionsButton.getPosition().y = 300f + 5 * 32f + 32f;
_exitButton.centerHorizontally();
_exitButton.getPosition().y = 300f + 3 * 32f + 64f;
_configButton.centerHorizontally();
_configButton.getPosition().y = 300f + 2 * 40f; |
<<<<<<<
import org.terasology.logic.manager.GUIManager;
import org.terasology.logic.world.BlockEntityRegistry;
import org.terasology.logic.world.WorldProvider;
=======
import org.terasology.logic.world.IWorldProvider;
>>>>>>>
import org.terasology.logic.world.BlockEntityRegistry;
import org.terasology.logic.world.WorldProvider;
<<<<<<<
import org.terasology.model.structures.BlockPosition;
=======
import org.terasology.model.blocks.management.BlockManager;
>>>>>>>
<<<<<<<
import org.terasology.rendering.gui.menus.UIContainerScreen;
=======
>>>>>>>
<<<<<<<
public void renderOverlay() {
// TODO: Don't render if not in first person?
// Display the block the player is aiming at
if (Config.getInstance().isPlacingBox()) {
RayBlockIntersection.Intersection selectedBlock = calcSelectedBlock();
if (selectedBlock != null) {
Block block = worldProvider.getBlock(selectedBlock.getBlockPosition());
if (block.isRenderBoundingBox()) {
block.getBounds(selectedBlock.getBlockPosition()).render(2f);
}
}
=======
@ReceiveEvent(components = {LocalPlayerComponent.class, InventoryComponent.class})
public void onAttackRequest(AttackButton event, EntityRef entity) {
if (!event.isDown() || timer.getTimeInMs() - lastInteraction < 200) {
return;
>>>>>>>
@ReceiveEvent(components = {LocalPlayerComponent.class, InventoryComponent.class})
public void onAttackRequest(AttackButton event, EntityRef entity) {
if (!event.isDown() || timer.getTimeInMs() - lastInteraction < 200) {
return;
}
LocalPlayerComponent localPlayerComp = entity.getComponent(LocalPlayerComponent.class);
InventoryComponent inventory = entity.getComponent(InventoryComponent.class);
if (localPlayerComp.isDead) return;
EntityRef selectedItemEntity = inventory.itemSlots.get(localPlayerComp.selectedTool);
attack(event.getTarget(), entity, selectedItemEntity);
lastInteraction = timer.getTimeInMs();
localPlayerComp.handAnimation = 0.5f;
entity.saveComponent(localPlayerComp);
event.consume();
}
private void attack(EntityRef target, EntityRef player, EntityRef selectedItemEntity) {
// TODO: Should send an attack event to self, and another system common to all creatures should handle this
int damage = 1;
ItemComponent item = selectedItemEntity.getComponent(ItemComponent.class);
if (item != null) {
damage = item.baseDamage;
BlockComponent blockComp = target.getComponent(BlockComponent.class);
if (blockComp != null) {
Block block = worldProvider.getBlock(blockComp.getPosition());
if (item.getPerBlockDamageBonus().containsKey(block.getBlockFamily().getTitle())) {
damage += item.getPerBlockDamageBonus().get(block.getBlockFamily().getTitle());
}
}
}
target.send(new DamageEvent(damage, player));
}
@ReceiveEvent(components = {LocalPlayerComponent.class})
public void onFrobRequest(FrobButton event, EntityRef entity) {
if (event.getState() != ButtonState.DOWN) {
return;
}
LocalPlayerComponent localPlayerComp = entity.getComponent(LocalPlayerComponent.class);
if (localPlayerComp.isDead) return;
event.getTarget().send(new ActivateEvent(entity, entity));
event.consume();
}
@ReceiveEvent(components = {LocalPlayerComponent.class})
public void onNextItem(ToolbarNextButton event, EntityRef entity) {
LocalPlayerComponent localPlayerComp = localPlayer.getEntity().getComponent(LocalPlayerComponent.class);
localPlayerComp.selectedTool = (localPlayerComp.selectedTool + 1) % 9;
localPlayer.getEntity().saveComponent(localPlayerComp);
event.consume();
}
@ReceiveEvent(components = {LocalPlayerComponent.class})
public void onPrevItem(ToolbarPrevButton event, EntityRef entity) {
LocalPlayerComponent localPlayerComp = localPlayer.getEntity().getComponent(LocalPlayerComponent.class);
localPlayerComp.selectedTool = (localPlayerComp.selectedTool - 1) % 9;
if (localPlayerComp.selectedTool < 0) {
localPlayerComp.selectedTool = 9 + localPlayerComp.selectedTool;
}
localPlayer.getEntity().saveComponent(localPlayerComp);
event.consume();
}
@ReceiveEvent(components = {LocalPlayerComponent.class})
public void onSlotButton(ToolbarSlotButton event, EntityRef entity) {
LocalPlayerComponent localPlayerComp = entity.getComponent(LocalPlayerComponent.class);
localPlayerComp.selectedTool = event.getSlot();
localPlayer.getEntity().saveComponent(localPlayerComp);
}
@ReceiveEvent(components = {LocalPlayerComponent.class, InventoryComponent.class})
public void onUseItemRequest(UseItemButton event, EntityRef entity) {
if (!event.isDown() || timer.getTimeInMs() - lastInteraction < 200) {
return;
<<<<<<<
* Attacks with currently held item
*/
// TODO: Move this somewhere more central, for use by all creatures. And activate with event
private void attack(EntityRef player, EntityRef withItem) {
RayBlockIntersection.Intersection selectedBlock = calcSelectedBlock();
ItemComponent item = withItem.getComponent(ItemComponent.class);
if (selectedBlock != null) {
BlockPosition blockPos = selectedBlock.getBlockPosition();
Block block = worldProvider.getBlock(blockPos.x, blockPos.y, blockPos.z);
int damage = 1;
if (item != null) {
damage = item.baseDamage;
if (item.getPerBlockDamageBonus().containsKey(block.getBlockFamily().getTitle())) {
damage += item.getPerBlockDamageBonus().get(block.getBlockFamily().getTitle());
}
}
EntityRef blockEntity = blockEntityRegistry.getOrCreateEntityAt(blockPos);
blockEntity.send(new DamageEvent(damage, player));
}
}
public void updateInput() {
// Process interactions even if the mouse button is pressed down
// and not fired by a repeated event
processInteractions(-1);
movementInput.set(0, 0, 0);
lookInput.set((float)(mouseSensititivy * Mouse.getDX()), (float)(mouseSensititivy * Mouse.getDY()));
if (Keyboard.isKeyDown(Keyboard.KEY_W)) {
movementInput.z -= 1.0f;
}
if (Keyboard.isKeyDown(Keyboard.KEY_S)) {
movementInput.z += 1.0f;
}
if (Keyboard.isKeyDown(Keyboard.KEY_A)) {
movementInput.x -= 1.0f;
}
if (Keyboard.isKeyDown(Keyboard.KEY_D)) {
movementInput.x += 1.0f;
}
if (Keyboard.isKeyDown(Keyboard.KEY_SPACE)) {
movementInput.y += 1.0f;
}
if (Keyboard.isKeyDown(Keyboard.KEY_C)) {
movementInput.y -= 1.0f;
}
running = Keyboard.isKeyDown(Keyboard.KEY_LSHIFT);
}
/**
=======
>>>>>>> |
<<<<<<<
import org.terasology.logic.common.DisplayNameComponent;
import org.terasology.registry.CoreRegistry;
=======
>>>>>>>
<<<<<<<
private EntityRef globalEntity;
public BehaviorSystem() {
CoreRegistry.put(BehaviorSystem.class, this);
}
=======
>>>>>>> |
<<<<<<<
import java.util.HashMap;
=======
>>>>>>>
import java.util.HashMap;
<<<<<<<
import org.lwjgl.opengl.Display;
import org.terasology.rendering.gui.framework.style.UIStyle;
=======
>>>>>>>
import org.lwjgl.opengl.Display;
import org.terasology.rendering.gui.framework.style.UIStyle; |
<<<<<<<
=======
import javax.vecmath.Vector3f;
import org.terasology.componentSystem.block.BlockEntityRegistry;
>>>>>>>
<<<<<<<
private WorldProvider worldProvider;
=======
private IWorldProvider worldProvider;
>>>>>>>
private WorldProvider worldProvider;
<<<<<<<
Block currentBlock = worldProvider.getBlock(blockPos);
=======
byte currentBlockType = worldProvider.getBlock(blockPos);
>>>>>>>
Block currentBlock = worldProvider.getBlock(blockPos); |
<<<<<<<
/*
* Copyright 2013 MovingBlocks
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.terasology.engine.entitySystem.event.internal;
=======
// Copyright 2021 The Terasology Foundation
// SPDX-License-Identifier: Apache-2.0
package org.terasology.entitySystem.event.internal;
>>>>>>>
// Copyright 2021 The Terasology Foundation
// SPDX-License-Identifier: Apache-2.0
package org.terasology.engine.entitySystem.event.internal; |
<<<<<<<
playerCamera = new OpenVRStereoCamera(vrProvider);
/*
* The origin of OpenVR's coordinate system lies on the ground of the user. We have to move this origin
* such that the ground plane of the rendering system and the ground plane of the room the VR user is
* in match.
*/
vrProvider.getState().setGroundPlaneYOffset(
GROUND_PLANE_HEIGHT_DISPARITY - context.get(Config.class).getPlayer().getEyeHeight());
=======
playerCamera = new OpenVRStereoCamera(vrProvider, worldProvider, renderingConfig);
>>>>>>>
playerCamera = new OpenVRStereoCamera(vrProvider, worldProvider, renderingConfig);
/*
* The origin of OpenVR's coordinate system lies on the ground of the user. We have to move this origin
* such that the ground plane of the rendering system and the ground plane of the room the VR user is
* in match.
*/
vrProvider.getState().setGroundPlaneYOffset(
GROUND_PLANE_HEIGHT_DISPARITY - context.get(Config.class).getPlayer().getEyeHeight()); |
<<<<<<<
=======
@Override
public boolean isTheDefaultInstance() {
return this.equals(defaultInstance);
}
/**
* Instances of this class bind a texture to a texture unit. The integer identifying
* the texture unit is then passed to a shader program using the material/parameter
* pair provided on construction. See the source of the execute() method for the
* nitty gritty details.
*
* WARNING: RenderPipelineTasks are not meant for direct instantiation and manipulation.
* Modules or other parts of the engine should take advantage of them through classes
* inheriting from StateChange.
*/
private class SetInputTextureTask implements RenderPipelineTask {
private final int textureSlot;
private final int textureId;
private final Material material;
private final String materialParameter;
private SetInputTextureTask(int textureSlot, int textureId, ResourceUrn materialURN, String materialParameter) {
this.textureSlot = textureSlot;
this.textureId = textureId;
this.material = getMaterial(materialURN);
this.materialParameter = materialParameter;
}
@Override
public void execute() {
glActiveTexture(GL_TEXTURE0 + textureSlot);
glBindTexture(GL_TEXTURE_2D, textureId);
material.setInt(materialParameter, textureSlot, true);
}
@Override
public String toString() {
return String.format("%30s: slot %s, texture %s, material %s, parameter %s", this.getClass().getSimpleName(),
textureSlot, textureId, material.getUrn().toString(), materialParameter);
}
}
>>>>>>>
/**
* Instances of this class bind a texture to a texture unit. The integer identifying
* the texture unit is then passed to a shader program using the material/parameter
* pair provided on construction. See the source of the execute() method for the
* nitty gritty details.
*
* WARNING: RenderPipelineTasks are not meant for direct instantiation and manipulation.
* Modules or other parts of the engine should take advantage of them through classes
* inheriting from StateChange.
*/
private class SetInputTextureTask implements RenderPipelineTask {
private final int textureSlot;
private final int textureId;
private final Material material;
private final String materialParameter;
private SetInputTextureTask(int textureSlot, int textureId, ResourceUrn materialURN, String materialParameter) {
this.textureSlot = textureSlot;
this.textureId = textureId;
this.material = getMaterial(materialURN);
this.materialParameter = materialParameter;
}
@Override
public void execute() {
glActiveTexture(GL_TEXTURE0 + textureSlot);
glBindTexture(GL_TEXTURE_2D, textureId);
material.setInt(materialParameter, textureSlot, true);
}
@Override
public String toString() {
return String.format("%30s: slot %s, texture %s, material %s, parameter %s", this.getClass().getSimpleName(),
textureSlot, textureId, material.getUrn().toString(), materialParameter);
}
} |
<<<<<<<
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
=======
import org.terasology.assets.management.AssetManager;
>>>>>>>
import org.terasology.assets.management.AssetManager;
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
<<<<<<<
import org.terasology.registry.CoreRegistry;
=======
>>>>>>>
import org.terasology.registry.CoreRegistry;
<<<<<<<
public Environment(Name ... moduleNames) {
=======
public Environment(Name... moduleNames) {
>>>>>>>
public Environment(Name... moduleNames) { |
<<<<<<<
public void postInitialise(Context context) {
context.put(RenderingSubsystemFactory.class, new HeadlessRenderingSubsystemFactory());
=======
public void initialise(Config config) {
}
@Override
public void registerCoreAssetTypes(ModuleAwareAssetTypeManager assetTypeManager) {
assetTypeManager.registerCoreAssetType(Font.class, FontImpl::new, "fonts");
assetTypeManager.registerCoreAssetType(Texture.class, HeadlessTexture::new, "textures", "fonts");
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.NEAREST, path -> path.getName(1).toString().equals("textures")));
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.LINEAR, path -> path.getName(1).toString().equals("fonts")));
assetTypeManager.registerCoreAssetType(Shader.class, HeadlessShader::new, "shaders");
assetTypeManager.registerCoreAssetType(Material.class, HeadlessMaterial::new, "materials");
assetTypeManager.registerCoreAssetType(Mesh.class, HeadlessMesh::new, "mesh");
assetTypeManager.registerCoreAssetType(SkeletalMesh.class, HeadlessSkeletalMesh::new, "skeletalMesh");
assetTypeManager.registerCoreAssetType(MeshAnimation.class, MeshAnimationImpl::new, "animations");
assetTypeManager.registerCoreAssetType(Atlas.class, Atlas::new, "atlas");
assetTypeManager.registerCoreAssetType(Subtexture.class, Subtexture::new);
}
@Override
public void postInitialise(Config config) {
CoreRegistry.putPermanently(RenderingSubsystemFactory.class, new HeadlessRenderingSubsystemFactory());
>>>>>>>
public void initialise(Context context) {
}
@Override
public void registerCoreAssetTypes(ModuleAwareAssetTypeManager assetTypeManager) {
assetTypeManager.registerCoreAssetType(Font.class, FontImpl::new, "fonts");
assetTypeManager.registerCoreAssetType(Texture.class, HeadlessTexture::new, "textures", "fonts");
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.NEAREST, path -> path.getName(1).toString().equals("textures")));
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.LINEAR, path -> path.getName(1).toString().equals("fonts")));
assetTypeManager.registerCoreAssetType(Shader.class, HeadlessShader::new, "shaders");
assetTypeManager.registerCoreAssetType(Material.class, HeadlessMaterial::new, "materials");
assetTypeManager.registerCoreAssetType(Mesh.class, HeadlessMesh::new, "mesh");
assetTypeManager.registerCoreAssetType(SkeletalMesh.class, HeadlessSkeletalMesh::new, "skeletalMesh");
assetTypeManager.registerCoreAssetType(MeshAnimation.class, MeshAnimationImpl::new, "animations");
assetTypeManager.registerCoreAssetType(Atlas.class, Atlas::new, "atlas");
assetTypeManager.registerCoreAssetType(Subtexture.class, Subtexture::new);
}
@Override
public void postInitialise(Context context) {
context.put(RenderingSubsystemFactory.class, new HeadlessRenderingSubsystemFactory());
<<<<<<<
private void initHeadless(Context context) {
AssetManager assetManager = context.get(AssetManager.class);
assetManager.setAssetFactory(AssetType.FONT, new AssetFactory<FontData, Font>() {
@Override
public Font buildAsset(AssetUri uri, FontData data) {
return new FontImpl(uri, data);
}
});
assetManager.setAssetFactory(AssetType.TEXTURE, new AssetFactory<TextureData, Texture>() {
@Override
public Texture buildAsset(AssetUri uri, TextureData data) {
return new HeadlessTexture(uri, data);
}
});
assetManager.setAssetFactory(AssetType.SHADER, new AssetFactory<ShaderData, Shader>() {
@Override
public Shader buildAsset(AssetUri uri, ShaderData data) {
return new HeadlessShader(uri, data);
}
});
assetManager.setAssetFactory(AssetType.MATERIAL, new AssetFactory<MaterialData, Material>() {
@Override
public Material buildAsset(AssetUri uri, MaterialData data) {
return new HeadlessMaterial(uri, data);
}
});
assetManager.setAssetFactory(AssetType.MESH, new AssetFactory<MeshData, Mesh>() {
@Override
public Mesh buildAsset(AssetUri uri, MeshData data) {
return new HeadlessMesh(uri, data);
}
});
assetManager.setAssetFactory(AssetType.SKELETON_MESH, new AssetFactory<SkeletalMeshData, SkeletalMesh>() {
@Override
public SkeletalMesh buildAsset(AssetUri uri, SkeletalMeshData data) {
return new HeadlessSkeletalMesh(uri, data);
}
});
assetManager.setAssetFactory(AssetType.ANIMATION, new AssetFactory<MeshAnimationData, MeshAnimation>() {
@Override
public MeshAnimation buildAsset(AssetUri uri, MeshAnimationData data) {
return new MeshAnimationImpl(uri, data);
}
});
assetManager.setAssetFactory(AssetType.ATLAS, new AssetFactory<AtlasData, Atlas>() {
@Override
public Atlas buildAsset(AssetUri uri, AtlasData data) {
return new Atlas(uri, data);
}
});
assetManager.setAssetFactory(AssetType.SUBTEXTURE, new AssetFactory<SubtextureData, Subtexture>() {
@Override
public Subtexture buildAsset(AssetUri uri, SubtextureData data) {
return new Subtexture(uri, data);
}
});
assetManager.addResolver(AssetType.SUBTEXTURE, new SubtextureFromAtlasResolver());
assetManager.addResolver(AssetType.TEXTURE, new ColorTextureAssetResolver());
assetManager.addResolver(AssetType.TEXTURE, new NoiseTextureAssetResolver());
assetManager.addResolver(AssetType.MESH, new IconMeshResolver());
// TODO: why headless cares about shaders?
context.put(ShaderManager.class, new ShaderManagerHeadless());
=======
private void initHeadless() {
CoreRegistry.putPermanently(ShaderManager.class, new ShaderManagerHeadless());
>>>>>>>
private void initHeadless(Context context) {
context.put(ShaderManager.class, new ShaderManagerHeadless()); |
<<<<<<<
import org.terasology.asset.AssetFactory;
import org.terasology.asset.AssetManager;
import org.terasology.asset.AssetManagerImpl;
import org.terasology.asset.AssetType;
import org.terasology.asset.AssetUri;
import org.terasology.context.internal.ContextImpl;
import org.terasology.engine.bootstrap.EntitySystemSetupUtil;
=======
import org.terasology.assets.management.AssetManager;
import org.terasology.assets.module.ModuleAwareAssetTypeManager;
import org.terasology.engine.bootstrap.EntitySystemBuilder;
>>>>>>>
import org.terasology.assets.management.AssetManager;
import org.terasology.assets.module.ModuleAwareAssetTypeManager;
import org.terasology.context.internal.ContextImpl;
import org.terasology.engine.bootstrap.EntitySystemSetupUtil;
<<<<<<<
context.put(ModuleManager.class, moduleManager);
AssetManager assetManager = new AssetManagerImpl(moduleManager.getEnvironment());
context.put(AssetManager.class, assetManager);
AssetType.registerAssetTypes(assetManager);
assetManager.setAssetFactory(AssetType.PREFAB, new AssetFactory<PrefabData, Prefab>() {
@Override
public Prefab buildAsset(AssetUri uri, PrefabData data) {
return new PojoPrefab(uri, data);
}
});
=======
CoreRegistry.put(ModuleManager.class, moduleManager);
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.registerCoreAssetType(Prefab.class, PojoPrefab::new, "prefabs");
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
CoreRegistry.put(AssetManager.class, assetTypeManager.getAssetManager());
>>>>>>>
context.put(ModuleManager.class, moduleManager);
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.registerCoreAssetType(Prefab.class, PojoPrefab::new, "prefabs");
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
context.put(AssetManager.class, assetTypeManager.getAssetManager()); |
<<<<<<<
import org.terasology.components.*;
import org.terasology.components.world.BlockComponent;
import org.terasology.components.world.BlockItemComponent;
import org.terasology.components.world.LocationComponent;
import org.terasology.entitySystem.*;
=======
import org.terasology.componentSystem.block.BlockEntityRegistry;
import org.terasology.components.AABBCollisionComponent;
import org.terasology.components.BlockComponent;
import org.terasology.components.BlockItemComponent;
import org.terasology.components.HealthComponent;
import org.terasology.components.ItemComponent;
import org.terasology.components.LocationComponent;
import org.terasology.components.PlayerComponent;
import org.terasology.entitySystem.*;
>>>>>>>
import org.terasology.components.AABBCollisionComponent;
import org.terasology.components.HealthComponent;
import org.terasology.components.ItemComponent;
import org.terasology.components.PlayerComponent;
import org.terasology.components.world.BlockComponent;
import org.terasology.components.world.BlockItemComponent;
import org.terasology.components.world.LocationComponent;
import org.terasology.entitySystem.*;
<<<<<<<
import javax.vecmath.Vector3f;
=======
>>>>>>>
import javax.vecmath.Vector3f; |
<<<<<<<
import org.eaxy.Document;
import org.eaxy.Element;
import org.eaxy.ElementSet;
import org.eaxy.NonMatchingPathException;
import org.eaxy.Xml;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.terasology.math.geom.Matrix4f;
import org.terasology.math.geom.Quat4f;
import org.terasology.math.geom.Vector2f;
import org.terasology.math.geom.Vector3f;
import org.terasology.rendering.assets.skeletalmesh.Bone;
import org.terasology.rendering.assets.skeletalmesh.BoneWeight;
import org.terasology.rendering.assets.skeletalmesh.SkeletalMeshDataBuilder;
import com.google.common.collect.Lists;
=======
>>>>>>>
import org.terasology.math.geom.Matrix4f;
import org.terasology.math.geom.Quat4f;
import org.terasology.math.geom.Vector2f;
import org.terasology.math.geom.Vector3f; |
<<<<<<<
import org.terasology.identity.storageServiceClient.StorageServiceWorker;
=======
import org.terasology.i18n.TranslationSystem;
>>>>>>>
import org.terasology.identity.storageServiceClient.StorageServiceWorker;
import org.terasology.i18n.TranslationSystem; |
<<<<<<<
@RegisterComponentSystem()
public class BookshelfHandler implements EventHandlerSystem{
=======
public class BookshelfHandler implements EventHandlerSystem {
@Override
>>>>>>>
@RegisterComponentSystem()
public class BookshelfHandler implements EventHandlerSystem{
@Override
<<<<<<<
@Override
public void shutdown() {
}
@ReceiveEvent(components=BookshelfComponent.class,priority=ReceiveEvent.PRIORITY_HIGH)
=======
@ReceiveEvent(components = BookshelfComponent.class, priority = EventPriority.PRIORITY_HIGH)
>>>>>>>
@Override
public void shutdown() {
}
@ReceiveEvent(components = BookshelfComponent.class, priority = EventPriority.PRIORITY_HIGH) |
<<<<<<<
import com.google.gson.Gson;
=======
import org.joml.Vector3f;
>>>>>>>
import com.google.gson.Gson;
import org.joml.Vector3f;
<<<<<<<
import org.terasology.engine.TerasologyConstants;
import org.terasology.math.geom.Vector3f;
=======
import org.terasology.engine.module.ModuleContext;
>>>>>>>
import org.terasology.engine.TerasologyConstants;
import org.terasology.engine.module.ModuleContext; |
<<<<<<<
import org.terasology.componentSystem.controllers.LocalPlayerSystem;
import org.terasology.components.LocalPlayerComponent;
import org.terasology.components.world.LocationComponent;
=======
import org.terasology.componentSystem.action.*;
import org.terasology.componentSystem.block.BlockEntityRegistry;
import org.terasology.componentSystem.block.BlockEntitySystem;
import org.terasology.componentSystem.characters.CharacterMovementSystem;
import org.terasology.componentSystem.characters.CharacterSoundSystem;
import org.terasology.componentSystem.common.HealthSystem;
import org.terasology.componentSystem.common.StatusAffectorSystem;
import org.terasology.componentSystem.controllers.*;
import org.terasology.componentSystem.items.InventorySystem;
import org.terasology.componentSystem.items.ItemSystem;
import org.terasology.componentSystem.rendering.BlockDamageRenderer;
import org.terasology.componentSystem.rendering.FirstPersonRenderer;
import org.terasology.componentSystem.rendering.MeshRenderer;
import org.terasology.components.*;
import org.terasology.components.actions.*;
>>>>>>>
import org.terasology.componentSystem.controllers.LocalPlayerSystem;
import org.terasology.components.LocalPlayerComponent;
import org.terasology.components.world.LocationComponent;
<<<<<<<
import org.terasology.entitySystem.ComponentSystem;
import org.terasology.entitySystem.EntityRef;
import org.terasology.entitySystem.PersistableEntityManager;
import org.terasology.entitySystem.persistence.EntityDataJSONFormat;
import org.terasology.entitySystem.persistence.EntityPersisterHelper;
import org.terasology.entitySystem.persistence.EntityPersisterHelperImpl;
import org.terasology.entitySystem.persistence.WorldPersister;
=======
import org.terasology.entitySystem.*;
import org.terasology.entitySystem.metadata.ComponentLibrary;
import org.terasology.entitySystem.metadata.ComponentLibraryImpl;
import org.terasology.entitySystem.metadata.extension.*;
import org.terasology.entitySystem.persistence.EntityDataJSONFormat;
import org.terasology.entitySystem.persistence.EntityPersisterHelper;
import org.terasology.entitySystem.persistence.EntityPersisterHelperImpl;
import org.terasology.entitySystem.persistence.WorldPersister;
import org.terasology.entitySystem.pojo.PojoEntityManager;
import org.terasology.entitySystem.pojo.PojoEventSystem;
import org.terasology.entitySystem.pojo.PojoPrefabManager;
import org.terasology.events.input.*;
import org.terasology.events.input.binds.InventoryButton;
>>>>>>>
import org.terasology.entitySystem.ComponentSystem;
import org.terasology.entitySystem.EntityRef;
import org.terasology.entitySystem.EventSystem;
import org.terasology.entitySystem.PersistableEntityManager;
import org.terasology.entitySystem.persistence.EntityDataJSONFormat;
import org.terasology.entitySystem.persistence.EntityPersisterHelper;
import org.terasology.entitySystem.persistence.EntityPersisterHelperImpl;
import org.terasology.entitySystem.persistence.WorldPersister;
import org.terasology.events.input.*;
import org.terasology.events.input.binds.InventoryButton;
<<<<<<<
import org.terasology.game.Timer;
import org.terasology.game.bootstrap.EntitySystemBuilder;
=======
import org.terasology.input.BindButtonEvent;
import org.terasology.input.CameraTargetSystem;
import org.terasology.input.InputSystem;
>>>>>>>
import org.terasology.game.Timer;
import org.terasology.game.bootstrap.EntitySystemBuilder;
import org.terasology.input.BindButtonEvent;
import org.terasology.input.CameraTargetSystem;
import org.terasology.input.InputSystem;
<<<<<<<
import org.terasology.logic.manager.AssetManager;
import org.terasology.logic.manager.Config;
import org.terasology.logic.manager.GUIManager;
import org.terasology.logic.manager.PathManager;
=======
import org.terasology.logic.manager.AssetManager;
import org.terasology.logic.manager.GUIManager;
import org.terasology.logic.manager.PathManager;
>>>>>>>
import org.terasology.logic.manager.AssetManager;
import org.terasology.logic.manager.GUIManager;
import org.terasology.logic.manager.PathManager;
<<<<<<<
import org.terasology.model.blocks.management.BlockManager;
=======
import org.terasology.model.blocks.BlockFamily;
import org.terasology.model.shapes.BlockShapeManager;
import org.terasology.mods.miniions.components.MinionBarComponent;
import org.terasology.mods.miniions.components.MinionComponent;
import org.terasology.mods.miniions.components.MinionControllerComponent;
import org.terasology.mods.miniions.components.SimpleMinionAIComponent;
import org.terasology.mods.miniions.componentsystem.controllers.MinionSystem;
import org.terasology.mods.miniions.componentsystem.controllers.SimpleMinionAISystem;
>>>>>>>
import org.terasology.model.blocks.management.BlockManager;
<<<<<<<
private PersistableEntityManager entityManager;
/* GUI */
private ArrayList<UIDisplayElement> _guiScreens = new ArrayList<UIDisplayElement>();
private UIHeadsUpDisplay _hud;
private UIMetrics _metrics;
private UIPauseMenu _pauseMenu;
private UILoadingScreen _loadingScreen;
private UIStatusScreen _statusScreen;
private UIInventoryScreen _inventoryScreen;
=======
>>>>>>>
private PersistableEntityManager entityManager;
<<<<<<<
entityManager = new EntitySystemBuilder().build();
componentSystemManager = new ComponentSystemManager();
CoreRegistry.put(ComponentSystemManager.class, componentSystemManager);
localPlayerSys = new LocalPlayerSystem();
componentSystemManager.register(localPlayerSys, "engine:LocalPlayerSystem");
componentSystemManager.loadEngineSystems();
CoreRegistry.put(WorldPersister.class, new WorldPersister(entityManager));
=======
BlockShapeManager.getInstance().reload();
componentLibrary = new ComponentLibraryImpl();
CoreRegistry.put(ComponentLibrary.class, componentLibrary);
componentLibrary.registerTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler());
componentLibrary.registerTypeHandler(Color4f.class, new Color4fTypeHandler());
componentLibrary.registerTypeHandler(Quat4f.class, new Quat4fTypeHandler());
componentLibrary.registerTypeHandler(Mesh.class, new AssetTypeHandler(AssetType.MESH, Mesh.class));
componentLibrary.registerTypeHandler(Sound.class, new AssetTypeHandler(AssetType.SOUND, Sound.class));
componentLibrary.registerTypeHandler(Material.class, new AssetTypeHandler(AssetType.MATERIAL, Material.class));
componentLibrary.registerTypeHandler(Vector3f.class, new Vector3fTypeHandler());
componentLibrary.registerTypeHandler(Vector2f.class, new Vector2fTypeHandler());
componentLibrary.registerTypeHandler(Vector3i.class, new Vector3iTypeHandler());
PrefabManager prefabManager = new PojoPrefabManager(componentLibrary);
CoreRegistry.put(PrefabManager.class, prefabManager);
_entityManager = new PojoEntityManager(componentLibrary, prefabManager);
EventSystem eventSystem = new PojoEventSystem(_entityManager);
_entityManager.setEventSystem(eventSystem);
CoreRegistry.put(EntityManager.class, _entityManager);
CoreRegistry.put(EventSystem.class, eventSystem);
_componentSystemManager = new ComponentSystemManager();
CoreRegistry.put(ComponentSystemManager.class, _componentSystemManager);
CoreRegistry.put(WorldPersister.class, new WorldPersister(componentLibrary,_entityManager));
// TODO: Use reflection pending mod support
eventSystem.registerEvent("engine:inputEvent", InputEvent.class);
eventSystem.registerEvent("engine:keyDownEvent", KeyDownEvent.class);
eventSystem.registerEvent("engine:keyEvent", KeyEvent.class);
eventSystem.registerEvent("engine:keyUpEvent", KeyUpEvent.class);
eventSystem.registerEvent("engine:keyRepeatEvent", KeyRepeatEvent.class);
eventSystem.registerEvent("engine:leftMouseDownButtonEvent", LeftMouseDownButtonEvent.class);
eventSystem.registerEvent("engine:leftMouseUpButtonEvent", LeftMouseUpButtonEvent.class);
eventSystem.registerEvent("engine:mouseDownButtonEvent", MouseDownButtonEvent.class);
eventSystem.registerEvent("engine:mouseUpButtonEvent", MouseUpButtonEvent.class);
eventSystem.registerEvent("engine:mouseButtonEvent", MouseButtonEvent.class);
eventSystem.registerEvent("engine:mouseWheelEvent", MouseWheelEvent.class);
eventSystem.registerEvent("engine:rightMouseDownButtonEvent", RightMouseDownButtonEvent.class);
eventSystem.registerEvent("engine:rightMouseUpButtonEvent", RightMouseUpButtonEvent.class);
eventSystem.registerEvent("engine:bindButtonEvent", BindButtonEvent.class);
eventSystem.registerEvent("engine:inventoryButtonEvent", InventoryButton.class);
// TODO: Use reflection pending mod support
componentLibrary.registerComponentClass(ExplosionActionComponent.class);
componentLibrary.registerComponentClass(PlaySoundActionComponent.class);
componentLibrary.registerComponentClass(TunnelActionComponent.class);
componentLibrary.registerComponentClass(AABBCollisionComponent.class);
componentLibrary.registerComponentClass(BlockComponent.class);
componentLibrary.registerComponentClass(BlockItemComponent.class);
componentLibrary.registerComponentClass(BlockParticleEffectComponent.class);
componentLibrary.registerComponentClass(CameraComponent.class);
componentLibrary.registerComponentClass(CharacterMovementComponent.class);
componentLibrary.registerComponentClass(CharacterSoundComponent.class);
componentLibrary.registerComponentClass(HealthComponent.class);
componentLibrary.registerComponentClass(InventoryComponent.class);
componentLibrary.registerComponentClass(ItemComponent.class);
componentLibrary.registerComponentClass(LightComponent.class);
componentLibrary.registerComponentClass(LocalPlayerComponent.class);
componentLibrary.registerComponentClass(LocationComponent.class);
componentLibrary.registerComponentClass(MeshComponent.class);
componentLibrary.registerComponentClass(PlayerComponent.class);
componentLibrary.registerComponentClass(SimpleAIComponent.class);
componentLibrary.registerComponentClass(SimpleMinionAIComponent.class);
componentLibrary.registerComponentClass(MinionBarComponent.class);
componentLibrary.registerComponentClass(MinionComponent.class);
componentLibrary.registerComponentClass(AccessInventoryActionComponent.class);
componentLibrary.registerComponentClass(SpawnPrefabActionComponent.class);
componentLibrary.registerComponentClass(BookComponent.class);
componentLibrary.registerComponentClass(BookshelfComponent.class);
componentLibrary.registerComponentClass(PotionComponent.class);
componentLibrary.registerComponentClass(SpeedBoostComponent.class);
componentLibrary.registerComponentClass(PoisonedComponent.class);
componentLibrary.registerComponentClass(MinionControllerComponent.class);
componentLibrary.registerComponentClass(CuredComponent.class);
>>>>>>>
entityManager = new EntitySystemBuilder().build();
componentSystemManager = new ComponentSystemManager();
CoreRegistry.put(ComponentSystemManager.class, componentSystemManager);
localPlayerSys = new LocalPlayerSystem();
componentSystemManager.register(localPlayerSys, "engine:LocalPlayerSystem");
cameraTargetSystem = new CameraTargetSystem();
CoreRegistry.put(CameraTargetSystem.class, cameraTargetSystem);
componentSystemManager.register(cameraTargetSystem, "engine:CameraTargetSystem");
inputSystem = new InputSystem();
CoreRegistry.put(InputSystem.class, inputSystem);
componentSystemManager.register(inputSystem, "engine:InputSystem");
componentSystemManager.loadEngineSystems();
componentSystemManager.loadSystems("miniions", "org.terasology.mods.miniions");
CoreRegistry.put(WorldPersister.class, new WorldPersister(entityManager));
// TODO: Use reflection pending mod support
EventSystem eventSystem = entityManager.getEventSystem();
eventSystem.registerEvent("engine:inputEvent", InputEvent.class);
eventSystem.registerEvent("engine:keyDownEvent", KeyDownEvent.class);
eventSystem.registerEvent("engine:keyEvent", KeyEvent.class);
eventSystem.registerEvent("engine:keyUpEvent", KeyUpEvent.class);
eventSystem.registerEvent("engine:keyRepeatEvent", KeyRepeatEvent.class);
eventSystem.registerEvent("engine:leftMouseDownButtonEvent", LeftMouseDownButtonEvent.class);
eventSystem.registerEvent("engine:leftMouseUpButtonEvent", LeftMouseUpButtonEvent.class);
eventSystem.registerEvent("engine:mouseDownButtonEvent", MouseDownButtonEvent.class);
eventSystem.registerEvent("engine:mouseUpButtonEvent", MouseUpButtonEvent.class);
eventSystem.registerEvent("engine:mouseButtonEvent", MouseButtonEvent.class);
eventSystem.registerEvent("engine:mouseWheelEvent", MouseWheelEvent.class);
eventSystem.registerEvent("engine:rightMouseDownButtonEvent", RightMouseDownButtonEvent.class);
eventSystem.registerEvent("engine:rightMouseUpButtonEvent", RightMouseUpButtonEvent.class);
eventSystem.registerEvent("engine:bindButtonEvent", BindButtonEvent.class);
eventSystem.registerEvent("engine:inventoryButtonEvent", InventoryButton.class);
<<<<<<<
for (ComponentSystem system : componentSystemManager.iterateAll()) {
system.shutdown();
}
=======
GUIManager.getInstance().closeWindows();
>>>>>>>
for (ComponentSystem system : componentSystemManager.iterateAll()) {
system.shutdown();
}
GUIManager.getInstance().closeWindows();
<<<<<<<
_loadingScreen.updateStatus(String.format("Fast forwarding world... %.2f%%! :-)", (timer.getTimeInMs() - startTime) / 50.0f));
=======
loadingScreen.updateStatus(String.format("Fast forwarding world... %.2f%%! :-)", (chunksGenerated / 64f) * 100f));
>>>>>>>
loadingScreen.updateStatus(String.format("Fast forwarding world... %.2f%%! :-)", (timer.getTimeInMs() - startTime) / 50.0f));
<<<<<<<
// Create the first Portal if it doesn't exist yet
_worldRenderer.initPortal();
_loadingScreen.setVisible(false);
_hud.setVisible(true);
_metrics.setVisible(true);
=======
GUIManager.getInstance().removeWindow(loadingScreen);
>>>>>>>
GUIManager.getInstance().removeWindow(loadingScreen);
// Create the first Portal if it doesn't exist yet
worldRenderer.initPortal(); |
<<<<<<<
context.put(ModuleManager.class, moduleManager);
context.put(Config.class, new Config());
context.put(AssetManager.class, new AssetManagerImpl(moduleManager.getEnvironment()));
context.put(NetworkSystem.class, networkSystem);
=======
CoreRegistry.put(ModuleManager.class, moduleManager);
CoreRegistry.put(Config.class, new Config());
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
CoreRegistry.put(AssetManager.class, assetTypeManager.getAssetManager());
CoreRegistry.put(NetworkSystem.class, networkSystem);
>>>>>>>
context.put(ModuleManager.class, moduleManager);
context.put(Config.class, new Config());
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
context.put(AssetManager.class, assetTypeManager.getAssetManager());
context.put(NetworkSystem.class, networkSystem);
<<<<<<<
BlockManagerImpl blockManager = new BlockManagerImpl(mock(WorldAtlas.class), new DefaultBlockFamilyFactoryRegistry());
context.put(BlockManager.class, blockManager);
testBlock = new Block();
testBlock.setId((short) 1);
blockManager.addBlockFamily(new SymmetricFamily(new BlockUri("test:testblock"), testBlock), true);
testBlock2 = new Block();
testBlock2.setId((short) 2);
blockManager.addBlockFamily(new SymmetricFamily(new BlockUri("test:testblock2"), testBlock2), true);
=======
BlockManagerImpl blockManager = CoreRegistry.put(BlockManager.class, new BlockManagerImpl(mock(WorldAtlas.class), assetTypeManager.getAssetManager()));
assetTypeManager.getAssetManager().loadAsset(new ResourceUrn("test:testblock"), new BlockFamilyDefinitionData(), BlockFamilyDefinition.class);
assetTypeManager.getAssetManager().loadAsset(new ResourceUrn("test:testblock2"), new BlockFamilyDefinitionData(), BlockFamilyDefinition.class);
testBlock = blockManager.getBlock("test:testblock");
testBlock2 = blockManager.getBlock("test:testblock2");
>>>>>>>
BlockManagerImpl blockManager = new BlockManagerImpl(mock(WorldAtlas.class), assetTypeManager.getAssetManager());
context.put(BlockManager.class, blockManager);
assetTypeManager.getAssetManager().loadAsset(new ResourceUrn("test:testblock"), new BlockFamilyDefinitionData(), BlockFamilyDefinition.class);
assetTypeManager.getAssetManager().loadAsset(new ResourceUrn("test:testblock2"), new BlockFamilyDefinitionData(), BlockFamilyDefinition.class);
testBlock = blockManager.getBlock("test:testblock");
testBlock2 = blockManager.getBlock("test:testblock2"); |
<<<<<<<
=======
import org.terasology.model.blocks.Block;
import org.terasology.utilities.MathHelper;
>>>>>>>
import org.terasology.utilities.MathHelper; |
<<<<<<<
=======
private static final Vector3f[] NEIGHBORS4 = {new Vector3f(-1, 0, 0), new Vector3f(1, 0, 0), new Vector3f(0, 0, 1), new Vector3f(0, 0, -1)};
private static final Vector3f[] NEIGHBORS6 = {new Vector3f(0, -1, 0), new Vector3f(0, 1, 0), new Vector3f(-1, 0, 0), new Vector3f(1, 0, 0), new Vector3f(0, 0, 1), new Vector3f(0, 0, -1)};
>>>>>>>
private static final Vector3f[] NEIGHBORS4 = {new Vector3f(-1, 0, 0), new Vector3f(1, 0, 0), new Vector3f(0, 0, 1), new Vector3f(0, 0, -1)};
private static final Vector3f[] NEIGHBORS6 = {new Vector3f(0, -1, 0), new Vector3f(0, 1, 0), new Vector3f(-1, 0, 0), new Vector3f(1, 0, 0), new Vector3f(0, 0, 1), new Vector3f(0, 0, -1)}; |
<<<<<<<
=======
import org.terasology.rendering.nui.baseWidgets.UIImage;
import org.terasology.rendering.nui.baseWidgets.UILabel;
import org.terasology.rendering.nui.baseWidgets.UISpace;
import org.terasology.rendering.nui.layout.ArbitraryLayout;
import org.terasology.rendering.nui.layout.ColumnLayout;
import org.terasology.version.TerasologyVersion;
import javax.vecmath.Vector2f;
>>>>>>>
import org.terasology.version.TerasologyVersion;
<<<<<<<
=======
public MainMenuScreen() {
ColumnLayout grid = new ColumnLayout();
grid.addWidget(new UIButton("singleplayer", "Single Player"));
grid.addWidget(new UIButton("multiplayer", "Host Game"));
grid.addWidget(new UIButton("join", "Join Game"));
grid.addWidget(new UIButton("settings", "Settings"));
grid.addWidget(new UISpace());
grid.addWidget(new UIButton("exit", "Exit"));
grid.setPadding(new Border(0, 0, 4, 4));
ArbitraryLayout layout = new ArbitraryLayout();
layout.addFixedWidget(new UIImage(Assets.getTexture("engine:terasology")), new Vector2i(512, 128), new Vector2f(0.5f, 0.2f));
layout.addFillWidget(new UILabel("version", "title", TerasologyVersion.getInstance().getHumanVersion()), Rect2f.createFromMinAndSize(0.0f, 0.3f, 1.0f, 0.1f));
layout.addFixedWidget(grid, new Vector2i(280, 192), new Vector2f(0.5f, 0.7f));
setContents(layout);
}
>>>>>>> |
<<<<<<<
public WorldRenderer getActiveWorldRenderer() {
return null;
}
public EntityManager getEntityManager() {
return null;
}
=======
>>>>>>>
public EntityManager getEntityManager() {
return null;
} |
<<<<<<<
=======
/**
* Updates the list of chunks around the player.
*
* @return True if the list was changed
*/
public boolean updateChunksInProximity(Region3i newRegion) {
if (!newRegion.equals(renderRegion)) {
Iterator<Vector3i> removeChunks = renderRegion.subtract(newRegion);
while (removeChunks.hasNext()) {
Vector3i pos = removeChunks.next();
Iterator<RenderableChunk> iterator = chunksInProximity.iterator();
while (iterator.hasNext()) {
RenderableChunk chunk = iterator.next();
if (chunk.getPosition().equals(pos)) {
chunk.disposeMesh();
iterator.remove();
break;
}
}
}
Iterator<Vector3i> addChunks = newRegion.subtract(renderRegion);
while (addChunks.hasNext()) {
Vector3i pos = addChunks.next();
RenderableChunk c = chunkProvider.getChunk(pos);
if (c != null) {
chunksInProximity.add(c);
}
}
renderRegion = newRegion;
Collections.sort(chunksInProximity, new ChunkFrontToBackComparator());
return true;
}
return false;
}
/**
* Updates the currently visible chunks (in sight of the player).
*/
public void updateAndQueueVisibleChunks() {
updateAndQueueVisibleChunks(true, true);
}
public int updateAndQueueVisibleChunks(boolean fillShadowRenderQueue, boolean processChunkUpdates) {
statDirtyChunks = 0;
statVisibleChunks = 0;
statIgnoredPhases = 0;
if (processChunkUpdates) {
PerformanceMonitor.startActivity("Building Mesh VBOs");
chunkMeshUpdateManager.setCameraPosition(activeCamera.getPosition());
for (RenderableChunk c : chunkMeshUpdateManager.availableChunksForUpdate()) {
if (chunksInProximity.contains(c) && c.getPendingMesh() != null) {
for (int i = 0; i < c.getPendingMesh().length; i++) {
c.getPendingMesh()[i].generateVBOs();
}
if (c.getMesh() != null) {
for (int i = 0; i < c.getMesh().length; i++) {
c.getMesh()[i].dispose();
}
}
c.setMesh(c.getPendingMesh());
c.setPendingMesh(null);
} else {
ChunkMesh[] pendingMesh = c.getPendingMesh();
c.setPendingMesh(null);
if (pendingMesh != null) {
for (ChunkMesh mesh : pendingMesh) {
mesh.dispose();
}
}
}
}
PerformanceMonitor.endActivity();
}
int processedChunks = 0;
for (int i = 0; i < chunksInProximity.size(); i++) {
RenderableChunk c = chunksInProximity.get(i);
ChunkMesh[] mesh = c.getMesh();
if (i < TeraMath.clamp(config.getRendering().getMaxChunksUsedForShadowMapping(), 64, 1024)
&& config.getRendering().isDynamicShadows() && fillShadowRenderQueue) {
if (isChunkVisibleLight(c) && isChunkValidForRender(c)) {
if (triangleCount(mesh, ChunkMesh.RenderPhase.OPAQUE) > 0) {
renderQueueChunksOpaqueShadow.add(c);
} else {
statIgnoredPhases++;
}
}
}
if (isChunkValidForRender(c)) {
if (isChunkVisible(c)) {
if (triangleCount(mesh, ChunkMesh.RenderPhase.OPAQUE) > 0) {
renderQueueChunksOpaque.add(c);
} else {
statIgnoredPhases++;
}
if (triangleCount(mesh, ChunkMesh.RenderPhase.REFRACTIVE) > 0) {
renderQueueChunksAlphaBlend.add(c);
} else {
statIgnoredPhases++;
}
if (triangleCount(mesh, ChunkMesh.RenderPhase.ALPHA_REJECT) > 0 && i < MAX_BILLBOARD_CHUNKS) {
renderQueueChunksAlphaReject.add(c);
} else {
statIgnoredPhases++;
}
statVisibleChunks++;
if (statVisibleChunks < MAX_ANIMATED_CHUNKS) {
c.setAnimated(true);
} else {
c.setAnimated(false);
}
}
if (isChunkVisibleReflection(c)) {
renderQueueChunksOpaqueReflection.add(c);
}
// Process all chunks in the area, not only the visible ones
if (processChunkUpdates && processChunkUpdate(c)) {
processedChunks++;
}
}
}
return processedChunks;
}
private int triangleCount(ChunkMesh[] mesh, ChunkMesh.RenderPhase type) {
int count = 0;
if (mesh != null) {
for (ChunkMesh subMesh : mesh) {
count += subMesh.triangleCount(type);
}
}
return count;
}
private boolean processChunkUpdate(RenderableChunk c) {
if ((c.isDirty() || c.getMesh() == null)) {
statDirtyChunks++;
chunkMeshUpdateManager.queueChunkUpdate(c);
return true;
}
return false;
}
>>>>>>> |
<<<<<<<
=======
import org.terasology.componentSystem.block.BlockEntitySystem;
import org.terasology.componentSystem.characters.CharacterMovementSystem;
import org.terasology.componentSystem.characters.CharacterSoundSystem;
import org.terasology.componentSystem.common.HealthSystem;
import org.terasology.componentSystem.common.StatusAffectorSystem;
>>>>>>>
<<<<<<<
=======
BlockShapeManager.getInstance().reload();
componentLibrary = new ComponentLibraryImpl();
CoreRegistry.put(ComponentLibrary.class, componentLibrary);
componentLibrary.registerTypeHandler(BlockFamily.class, new BlockFamilyTypeHandler());
componentLibrary.registerTypeHandler(Color4f.class, new Color4fTypeHandler());
componentLibrary.registerTypeHandler(Quat4f.class, new Quat4fTypeHandler());
componentLibrary.registerTypeHandler(Mesh.class, new AssetTypeHandler(AssetType.MESH, Mesh.class));
componentLibrary.registerTypeHandler(Sound.class, new AssetTypeHandler(AssetType.SOUND, Sound.class));
componentLibrary.registerTypeHandler(Material.class, new AssetTypeHandler(AssetType.MATERIAL, Material.class));
componentLibrary.registerTypeHandler(Vector3f.class, new Vector3fTypeHandler());
componentLibrary.registerTypeHandler(Vector2f.class, new Vector2fTypeHandler());
componentLibrary.registerTypeHandler(Vector3i.class, new Vector3iTypeHandler());
PrefabManager prefabManager = new PojoPrefabManager(componentLibrary);
CoreRegistry.put(PrefabManager.class, prefabManager);
_entityManager = new PojoEntityManager(componentLibrary, prefabManager);
_entityManager.setEventSystem(new PojoEventSystem(_entityManager));
CoreRegistry.put(EntityManager.class, _entityManager);
_componentSystemManager = new ComponentSystemManager();
CoreRegistry.put(ComponentSystemManager.class, _componentSystemManager);
CoreRegistry.put(WorldPersister.class, new WorldPersister(componentLibrary,_entityManager));
// TODO: Use reflection pending mod support
componentLibrary.registerComponentClass(ExplosionActionComponent.class);
componentLibrary.registerComponentClass(PlaySoundActionComponent.class);
componentLibrary.registerComponentClass(TunnelActionComponent.class);
componentLibrary.registerComponentClass(AABBCollisionComponent.class);
componentLibrary.registerComponentClass(BlockComponent.class);
componentLibrary.registerComponentClass(BlockItemComponent.class);
componentLibrary.registerComponentClass(BlockParticleEffectComponent.class);
componentLibrary.registerComponentClass(CameraComponent.class);
componentLibrary.registerComponentClass(CharacterMovementComponent.class);
componentLibrary.registerComponentClass(CharacterSoundComponent.class);
componentLibrary.registerComponentClass(HealthComponent.class);
componentLibrary.registerComponentClass(InventoryComponent.class);
componentLibrary.registerComponentClass(ItemComponent.class);
componentLibrary.registerComponentClass(LightComponent.class);
componentLibrary.registerComponentClass(LocalPlayerComponent.class);
componentLibrary.registerComponentClass(LocationComponent.class);
componentLibrary.registerComponentClass(MeshComponent.class);
componentLibrary.registerComponentClass(PlayerComponent.class);
componentLibrary.registerComponentClass(SimpleAIComponent.class);
componentLibrary.registerComponentClass(SimpleMinionAIComponent.class);
componentLibrary.registerComponentClass(MinionBarComponent.class);
componentLibrary.registerComponentClass(MinionComponent.class);
componentLibrary.registerComponentClass(AccessInventoryActionComponent.class);
componentLibrary.registerComponentClass(SpawnPrefabActionComponent.class);
componentLibrary.registerComponentClass(BookComponent.class);
componentLibrary.registerComponentClass(BookshelfComponent.class);
componentLibrary.registerComponentClass(PotionComponent.class);
componentLibrary.registerComponentClass(SpeedBoostComponent.class);
componentLibrary.registerComponentClass(PoisonedComponent.class);
loadPrefabs();
>>>>>>>
<<<<<<<
localPlayerSys = new LocalPlayerSystem();
componentSystemManager.register(localPlayerSys, "engine:LocalPlayerSystem");
componentSystemManager.register(blockEntityRegistry, "engine:BlockEntityRegistry");
componentSystemManager.loadEngineSystems();
CoreRegistry.put(WorldPersister.class, new WorldPersister(entityManager));
loadPrefabs();
=======
_componentSystemManager.register(new CharacterMovementSystem(), "engine:CharacterMovementSystem");
_componentSystemManager.register(new SimpleAISystem(), "engine:SimpleAISystem");
_componentSystemManager.register(new SimpleMinionAISystem(), "engine:SimpleMinionAISystem");
_componentSystemManager.register(new ItemSystem(), "engine:ItemSystem");
_componentSystemManager.register(new CharacterSoundSystem(), "engine:CharacterSoundSystem");
_localPlayerSys = new LocalPlayerSystem();
_componentSystemManager.register(_localPlayerSys, "engine:LocalPlayerSystem");
_componentSystemManager.register(new FirstPersonRenderer(), "engine:FirstPersonRenderer");
_componentSystemManager.register(new HealthSystem(), "engine:HealthSystem");
_componentSystemManager.register(new BlockEntitySystem(), "engine:BlockEntitySystem");
_componentSystemManager.register(new BlockParticleEmitterSystem(), "engine:BlockParticleSystem");
_componentSystemManager.register(new BlockDamageRenderer(), "engine:BlockDamageRenderer");
_componentSystemManager.register(new InventorySystem(), "engine:InventorySystem");
_componentSystemManager.register(new MeshRenderer(), "engine:MeshRenderer");
_componentSystemManager.register(new ExplosionAction(), "engine:ExplosionAction");
_componentSystemManager.register(new PlaySoundAction(), "engine:PlaySoundAction");
_componentSystemManager.register(new TunnelAction(), "engine:TunnelAction");
_componentSystemManager.register(new AccessInventoryAction(), "engine:AccessInventoryAction");
_componentSystemManager.register(new SpawnPrefabAction(), "engine:SpawnPrefabAction");
_componentSystemManager.register(new ReadBookAction(), "engine: ReadBookAction");
//_componentSystemManager.register(new DestroyMinion(), "engine: DestroyMinionAction");
_componentSystemManager.register(new BookshelfHandler(), "engine: BookshelfHandler");
_componentSystemManager.register(new DrinkPotionAction(), "engine : DrinkPotionAction");
_componentSystemManager.register(new StatusAffectorSystem(), "engine : StatusAffectorSystem");
>>>>>>>
localPlayerSys = new LocalPlayerSystem();
componentSystemManager.register(localPlayerSys, "engine:LocalPlayerSystem");
componentSystemManager.register(blockEntityRegistry, "engine:BlockEntityRegistry");
componentSystemManager.loadEngineSystems();
CoreRegistry.put(WorldPersister.class, new WorldPersister(entityManager));
loadPrefabs(); |
<<<<<<<
Vector3f cameraPosition = CoreRegistry.get(WorldRenderer.class).getActiveCamera().getPosition();
GL11.glTranslated(gp.x - cameraPosition.x, gp.y - cameraPosition.y, gp.z - cameraPosition.z);
=======
Vector3d cameraPosition = CoreRegistry.get(WorldRenderer.class).getActiveCamera().getPosition();
GL11.glTranslated(gp.position.x - cameraPosition.x, gp.position.y - cameraPosition.y, gp.position.z - cameraPosition.z);
>>>>>>>
Vector3f cameraPosition = CoreRegistry.get(WorldRenderer.class).getActiveCamera().getPosition();
GL11.glTranslated(gp.position.x - cameraPosition.x, gp.position.y - cameraPosition.y, gp.position.z - cameraPosition.z); |
<<<<<<<
import org.terasology.asset.AssetManager;
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
=======
import org.terasology.assets.format.AssetDataFile;
import org.terasology.assets.management.AssetManager;
>>>>>>>
import org.terasology.assets.format.AssetDataFile;
import org.terasology.assets.management.AssetManager;
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
<<<<<<<
context.put(BehaviorNodeFactory.class, nodeFactory);
BehaviorTreeLoader loader = new BehaviorTreeLoader();
=======
CoreRegistry.put(BehaviorNodeFactory.class, nodeFactory);
BehaviorTreeFormat loader = new BehaviorTreeFormat();
>>>>>>>
context.put(BehaviorNodeFactory.class, nodeFactory);
BehaviorTreeFormat loader = new BehaviorTreeFormat(); |
<<<<<<<
=======
private SingleChronicleQueueBuilder builder;
private long appendTimeout = 1_000;
>>>>>>>
private SingleChronicleQueueBuilder builder;
private long appendTimeout = 1_000;
<<<<<<<
this.mappedBytes = ((MappedBytes) wire.bytes()).withSizes(chunkSize, overlapSize);
=======
final MappedBytes bytes = (MappedBytes) wire.bytes();
MappedBytes mappedBytes = bytes.withSizes(chunkSize, overlapSize);
this.mappedFile = mappedBytes.mappedFile();
>>>>>>>
final MappedBytes bytes = (MappedBytes) wire.bytes();
MappedBytes mappedBytes = bytes.withSizes(chunkSize, overlapSize);
<<<<<<<
=======
public enum IndexOffset {
;
public static long toAddress0(long index) {
long siftedIndex = index >> (17L + 6L);
long mask = (1L << 17L) - 1L;
long maskedShiftedIndex = mask & siftedIndex;
// convert to an offset
return maskedShiftedIndex * 8L;
}
public static long toAddress1(long index) {
long siftedIndex = index >> (6L);
long mask = (1L << 17L) - 1L;
long maskedShiftedIndex = mask & siftedIndex;
// convert to an offset
return maskedShiftedIndex;// * 8L;
}
@NotNull
public static String toBinaryString(long i) {
StringBuilder sb = new StringBuilder();
for (int n = 63; n >= 0; n--)
sb.append(((i & (1L << n)) != 0 ? "1" : "0"));
return sb.toString();
}
@NotNull
public static String toScale() {
StringBuilder units = new StringBuilder();
StringBuilder tens = new StringBuilder();
for (int n = 64; n >= 1; n--)
units.append((0 == (n % 10)) ? "|" : n % 10);
for (int n = 64; n >= 1; n--)
tens.append((0 == (n % 10)) ? n / 10 : " ");
return units.toString() + "\n" + tens.toString();
}
}
// *************************************************************************
//
// *************************************************************************
enum RollFields implements WireKey {
cycle, length, format, timeZone, nextCycle, epoc, nextCycleMetaPosition, appendTimeout
}
>>>>>>>
public enum IndexOffset {
;
public static long toAddress0(long index) {
long siftedIndex = index >> (17L + 6L);
long mask = (1L << 17L) - 1L;
long maskedShiftedIndex = mask & siftedIndex;
// convert to an offset
return maskedShiftedIndex * 8L;
}
public static long toAddress1(long index) {
long siftedIndex = index >> (6L);
long mask = (1L << 17L) - 1L;
long maskedShiftedIndex = mask & siftedIndex;
// convert to an offset
return maskedShiftedIndex;// * 8L;
}
@NotNull
public static String toBinaryString(long i) {
StringBuilder sb = new StringBuilder();
for (int n = 63; n >= 0; n--)
sb.append(((i & (1L << n)) != 0 ? "1" : "0"));
return sb.toString();
}
@NotNull
public static String toScale() {
StringBuilder units = new StringBuilder();
StringBuilder tens = new StringBuilder();
for (int n = 64; n >= 1; n--)
units.append((0 == (n % 10)) ? "|" : n % 10);
for (int n = 64; n >= 1; n--)
tens.append((0 == (n % 10)) ? n / 10 : " ");
return units.toString() + "\n" + tens.toString();
}
}
// *************************************************************************
//
// *************************************************************************
enum RollFields implements WireKey {
cycle, length, format, timeZone, nextCycle, epoc, nextCycleMetaPosition, appendTimeout
} |
<<<<<<<
import javax.vecmath.Vector2f;
=======
import org.terasology.asset.AssetType;
import org.terasology.asset.AssetUri;
import org.terasology.components.CuredComponent;
>>>>>>>
import javax.vecmath.Vector2f;
import org.terasology.components.CuredComponent; |
<<<<<<<
import org.terasology.game.modes.IGameMode;
import org.terasology.game.modes.ModeMainMenu;
import org.terasology.game.modes.ModePlayGame;
import org.terasology.logic.characters.Player;
=======
>>>>>>>
import org.terasology.game.modes.IGameMode;
import org.terasology.game.modes.ModeMainMenu;
import org.terasology.game.modes.ModePlayGame;
import org.terasology.logic.characters.Player;
<<<<<<<
import java.util.Collections;
import java.util.EnumMap;
import java.util.Map;
=======
import java.util.Collections;
>>>>>>>
import java.util.Collections;
import java.util.EnumMap;
import java.util.Map;
<<<<<<<
/* THREADING */
=======
>>>>>>>
<<<<<<<
=======
>>>>>>>
<<<<<<<
=======
>>>>>>>
<<<<<<<
IGameMode mode;
=======
IGameMode mode = null;
>>>>>>>
IGameMode mode;
<<<<<<<
mode.processKeyboardInput();
mode.processMouseInput();
mode.updatePlayerInput();
PerformanceMonitor.endActivity();
=======
mode.processKeyboardInput();
mode.processMouseInput();
mode.updatePlayerInput();
PerformanceMonitor.endActivity();
>>>>>>>
mode.processKeyboardInput();
mode.processMouseInput();
mode.updatePlayerInput();
PerformanceMonitor.endActivity();
<<<<<<<
if (getActiveWorldRenderer() != null)
getGameMode().getActiveWorldRenderer().dispose();
=======
getGameMode().getActiveWorldRenderer().dispose();
>>>>>>>
if (getActiveWorldRenderer() != null)
getGameMode().getActiveWorldRenderer().dispose();
<<<<<<<
public IGameMode getGameMode() {
IGameMode mode = _gameModes.get(_state);
if (mode != null) {
return mode;
}
switch (_state) {
case runGame:
mode = new ModePlayGame();
break;
case mainMenu:
mode = new ModeMainMenu();
break;
case undefined:
getLogger().log(Level.SEVERE, "Undefined game state - unable to run");
return null;
}
_gameModes.put(_state, mode);
mode.init();
return mode;
}
public void setGameMode(GameMode state) {
_state = state;
}
public void render() {
getGameMode().render();
}
public void update() {
getGameMode().update();
=======
public void render() {
getGameMode().render();
}
public void update() {
getGameMode().update();
>>>>>>>
public void render() {
getGameMode().render();
}
public void update() {
getGameMode().update();
<<<<<<<
=======
public long getDelta() {
return _delta;
}
>>>>>>> |
<<<<<<<
import org.terasology.model.blocks.BlockManager;
import org.terasology.rendering.shader.ShaderParameters;
=======
import org.terasology.model.blocks.management.BlockManager;
>>>>>>>
import org.terasology.model.blocks.management.BlockManager;
import org.terasology.rendering.shader.ShaderParameters; |
<<<<<<<
nextSynchronous = builder.synchronous();
=======
capacityAddr = limitAddr;
nextSynchronous = config.synchronous();
>>>>>>>
nextSynchronous = builder.synchronous();
capacityAddr = limitAddr; |
<<<<<<<
=======
import org.terasology.config.Config;
>>>>>>>
import org.terasology.config.Config; |
<<<<<<<
import org.terasology.asset.AssetFactory;
import org.terasology.asset.AssetManager;
import org.terasology.asset.AssetManagerImpl;
import org.terasology.asset.AssetType;
import org.terasology.asset.AssetUri;
import org.terasology.asset.Assets;
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
=======
import org.terasology.assets.management.AssetManager;
import org.terasology.assets.module.ModuleAwareAssetTypeManager;
>>>>>>>
import org.terasology.assets.management.AssetManager;
import org.terasology.assets.module.ModuleAwareAssetTypeManager;
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
<<<<<<<
AssetManager assetManager = CoreRegistry.put(AssetManager.class, new AssetManagerImpl(moduleManager.getEnvironment()));
assetManager.setAssetFactory(AssetType.PREFAB, new AssetFactory<PrefabData, Prefab>() {
@Override
public Prefab buildAsset(AssetUri uri, PrefabData data) {
return new PojoPrefab(uri, data);
}
});
context.put(ComponentSystemManager.class, mock(ComponentSystemManager.class));
=======
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.registerCoreAssetType(Prefab.class, PojoPrefab::new, "prefabs");
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
AssetManager assetManager = CoreRegistry.put(AssetManager.class, assetTypeManager.getAssetManager());
EntitySystemBuilder builder = new EntitySystemBuilder();
CoreRegistry.put(ComponentSystemManager.class, mock(ComponentSystemManager.class));
>>>>>>>
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.registerCoreAssetType(Prefab.class, PojoPrefab::new, "prefabs");
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
AssetManager assetManager = assetTypeManager.getAssetManager();
context.put(AssetManager.class, assetManager);
context.put(ComponentSystemManager.class, mock(ComponentSystemManager.class));
<<<<<<<
context.put(NetworkSystem.class, networkSystem);
EntitySystemSetupUtil.addReflectionBasedLibraries(context);
EntitySystemSetupUtil.addEntityManagementRelatedClasses(context);
entityManager = context.get(EngineEntityManager.class);
worldStub = new WorldProviderCoreStub();
=======
entityManager = builder.build(moduleManager.getEnvironment(), networkSystem, new ReflectionReflectFactory());
worldStub = new WorldProviderCoreStub(airBlock, null);
>>>>>>>
context.put(NetworkSystem.class, networkSystem);
EntitySystemSetupUtil.addReflectionBasedLibraries(context);
EntitySystemSetupUtil.addEntityManagementRelatedClasses(context);
entityManager = context.get(EngineEntityManager.class);
worldStub = new WorldProviderCoreStub(airBlock, null); |
<<<<<<<
import org.terasology.components.ItemComponent;
import org.terasology.components.LocalPlayerComponent;
import org.terasology.components.world.LocationComponent;
import org.terasology.components.MinionBarComponent;
=======
import org.terasology.components.*;
import org.terasology.mods.miniions.components.MinionBarComponent;
>>>>>>>
import org.terasology.components.CharacterMovementComponent;
import org.terasology.components.InventoryComponent;
import org.terasology.components.ItemComponent;
import org.terasology.components.world.LocationComponent;
<<<<<<<
import org.terasology.game.*;
=======
import org.terasology.game.CoreRegistry;
>>>>>>>
import org.terasology.game.CoreRegistry;
<<<<<<<
boolean updatedThisFrame = false;
=======
>>>>>>>
boolean updatedThisFrame = false;
<<<<<<<
if (!updatedThisFrame && updateRigidBody(chunk)) {
updatedThisFrame = true;
}
=======
chunk.updateRigidBody();
>>>>>>>
if (!updatedThisFrame && updateRigidBody(chunk)) {
updatedThisFrame = true;
}
<<<<<<<
private boolean updateRigidBody(Chunk chunk) {
if (chunk.getRigidBody() != null || chunk.getMesh() == null)
return false;
// TODO: Lock on chunk meshes
TriangleIndexVertexArray vertexArray = new TriangleIndexVertexArray();
int tris = 0;
ChunkMesh[] meshes = chunk.getMesh();
for (int k = 0; k < Chunk.VERTICAL_SEGMENTS; k++) {
ChunkMesh mesh = meshes[k];
if (mesh != null) {
IndexedMesh indexedMesh = mesh._indexedMesh;
if (indexedMesh != null) {
tris += mesh._indexedMesh.numTriangles;
vertexArray.addIndexedMesh(indexedMesh);
}
mesh._indexedMesh = null;
}
}
// TODO: Deal with this situation better
if (tris == 0) {
return false;
}
try {
BvhTriangleMeshShape shape = new BvhTriangleMeshShape(vertexArray, true);
Matrix3f rot = new Matrix3f();
rot.setIdentity();
DefaultMotionState blockMotionState = new DefaultMotionState(new Transform(new Matrix4f(rot, new Vector3f((float) chunk.getPos().x * Chunk.SIZE_X, (float) chunk.getPos().y * Chunk.SIZE_Y, (float) chunk.getPos().z * Chunk.SIZE_Z), 1.0f)));
RigidBodyConstructionInfo blockConsInf = new RigidBodyConstructionInfo(0, blockMotionState, shape, new Vector3f());
RigidBody rigidBody = new RigidBody(blockConsInf);
chunk.setRigidBody(rigidBody);
} catch (Exception e) {
_logger.log(Level.WARNING, "Chunk failed to create rigid body.", e);
}
return true;
}
=======
@Override
>>>>>>>
private boolean updateRigidBody(Chunk chunk) {
if (chunk.getRigidBody() != null || chunk.getMesh() == null)
return false;
// TODO: Lock on chunk meshes
TriangleIndexVertexArray vertexArray = new TriangleIndexVertexArray();
int tris = 0;
ChunkMesh[] meshes = chunk.getMesh();
for (int k = 0; k < Chunk.VERTICAL_SEGMENTS; k++) {
ChunkMesh mesh = meshes[k];
if (mesh != null) {
IndexedMesh indexedMesh = mesh._indexedMesh;
if (indexedMesh != null) {
tris += mesh._indexedMesh.numTriangles;
vertexArray.addIndexedMesh(indexedMesh);
}
mesh._indexedMesh = null;
}
}
// TODO: Deal with this situation better
if (tris == 0) {
return false;
}
try {
BvhTriangleMeshShape shape = new BvhTriangleMeshShape(vertexArray, true);
Matrix3f rot = new Matrix3f();
rot.setIdentity();
DefaultMotionState blockMotionState = new DefaultMotionState(new Transform(new Matrix4f(rot, new Vector3f((float) chunk.getPos().x * Chunk.SIZE_X, (float) chunk.getPos().y * Chunk.SIZE_Y, (float) chunk.getPos().z * Chunk.SIZE_Z), 1.0f)));
RigidBodyConstructionInfo blockConsInf = new RigidBodyConstructionInfo(0, blockMotionState, shape, new Vector3f());
RigidBody rigidBody = new RigidBody(blockConsInf);
chunk.setRigidBody(rigidBody);
} catch (Exception e) {
_logger.log(Level.WARNING, "Chunk failed to create rigid body.", e);
}
return true;
}
@Override
<<<<<<<
block.renderWithLightValue(_parent.getRenderingLightValueAt(t.origin));
=======
block.renderWithLightValue(_parent.getRenderingLightValueAt(new Vector3d(t.origin)));
>>>>>>>
block.renderWithLightValue(_parent.getRenderingLightValueAt(t.origin)); |
<<<<<<<
import org.terasology.rendering.gui.framework.IInputDataElement;
=======
import org.terasology.logic.manager.AudioManager;
>>>>>>>
import org.terasology.rendering.gui.framework.IInputDataElement;
import org.terasology.logic.manager.AudioManager; |
<<<<<<<
import org.terasology.rendering.nui.UIWidget;
import org.terasology.rendering.nui.asset.UIElement;
import org.terasology.rendering.nui.events.NUICharEvent;
import org.terasology.rendering.nui.events.NUIKeyEvent;
=======
>>>>>>>
<<<<<<<
if (canvas.processMouseWheel(event.getWheelTurns(), mouse.getPosition())) {
=======
if (canvas.processMouseWheel(event.getWheelTurns(), mousePosition)) {
>>>>>>>
if (canvas.processMouseWheel(event.getWheelTurns(), mousePosition)) { |
<<<<<<<
byte blockId = type.getBlockIdFor(attachmentSide, direction);
if (blockId == 0)
return false;
worldProvider.setBlock(blockPos.x, blockPos.y, blockPos.z, blockId, true, true);
=======
placeBlock(blockPos, type.getBlockIdFor(attachmentSide, direction), true);
>>>>>>>
byte blockId = type.getBlockIdFor(attachmentSide, direction);
if (blockId == 0)
return false;
placeBlock(blockPos, blockId, true); |
<<<<<<<
/*GAME MODES*/
public enum GameMode {
undefined, mainMenu, runGame
};
static GameMode _state = GameMode.mainMenu;
private static Map<GameMode,IGameMode> _gameModes = Collections.synchronizedMap(new EnumMap<GameMode,IGameMode>(GameMode.class));
=======
/* GUI */
private ArrayList<UIDisplayElement> _guiScreens = new ArrayList<UIDisplayElement>();
private UIHeadsUpDisplay _hud;
private UIMetrics _metrics;
private UIPauseMenu _pauseMenu;
private UILoadingScreen _loadingScreen;
private UIStatusScreen _statusScreen;
private UIInventoryScreen _inventoryScreen;
>>>>>>>
/*GAME MODES*/
public enum GameMode {
undefined, mainMenu, runGame
};
static GameMode _state = GameMode.mainMenu;
private static Map<GameMode,IGameMode> _gameModes = Collections.synchronizedMap(new EnumMap<GameMode,IGameMode>(GameMode.class));
<<<<<<<
}
=======
}
>>>>>>>
}
<<<<<<<
IGameMode mode = null;
=======
PerformanceMonitor.startActivity("Other");
>>>>>>>
IGameMode mode = null;
PerformanceMonitor.startActivity("Other");
<<<<<<<
updateFps();
mode.updateTimeAccumulator(getTime(), startTime);
=======
_timeAccumulator += getTime() - startTime;
>>>>>>>
// MAIN GAME LOOP
while (_runGame && !Display.isCloseRequested()) {
// Only process rendering and updating once a second
if (!Display.isActive()) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
getInstance().getLogger().log(Level.SEVERE, e.toString(), e);
}
PerformanceMonitor.startActivity("Process Display");
Display.processMessages();
PerformanceMonitor.endActivity();
}
mode = getGameMode();
if(mode==null){
_runGame = false;
break;
}
PerformanceMonitor.startActivity("Main Update");
long startTime = getTime();
mode.update();
PerformanceMonitor.endActivity();
PerformanceMonitor.startActivity("Render");
mode.render();
updateFps();
Display.update();
Display.sync(60);
PerformanceMonitor.endActivity();
PerformanceMonitor.startActivity("Input");
mode.processKeyboardInput();
mode.processMouseInput();
mode.updatePlayerInput();
PerformanceMonitor.endActivity();
PerformanceMonitor.rollCycle();
PerformanceMonitor.startActivity("Other");
mode.updateTimeAccumulator(getTime(), startTime);
<<<<<<<
getGameMode().render();
=======
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
if (_activeWorldRenderer != null)
_activeWorldRenderer.render();
PerformanceMonitor.startActivity("Render UI");
renderUserInterface();
PerformanceMonitor.endActivity();
>>>>>>>
getGameMode().render();
<<<<<<<
getGameMode().update();
=======
if (_activeWorldRenderer != null && shouldUpdateWorld())
_activeWorldRenderer.update();
if (screenHasFocus() || !shouldUpdateWorld()) {
if (Mouse.isGrabbed()) {
Mouse.setGrabbed(false);
Mouse.setCursorPosition(Display.getWidth() / 2, Display.getHeight() / 2);
}
} else {
if (!Mouse.isGrabbed())
Mouse.setGrabbed(true);
}
if (_activeWorldRenderer != null) {
if (_activeWorldRenderer.getPlayer().isDead()) {
_statusScreen.setVisible(true);
_activeWorldRenderer.getPlayer().reset();
_statusScreen.updateStatus("Sorry. You've died. :-(");
} else {
_statusScreen.setVisible(false);
}
}
updateUserInterface();
}
private boolean screenHasFocus() {
for (UIDisplayElement screen : _guiScreens) {
if (screen.isVisible() && !screen.isOverlay()) {
return true;
}
}
return false;
}
private boolean screenCanFocus(UIDisplayElement s) {
boolean result = true;
for (UIDisplayElement screen : _guiScreens) {
if (screen.isVisible() && !screen.isOverlay() && screen != s)
result = false;
}
return result;
}
private boolean shouldUpdateWorld() {
return !_pauseGame && !_pauseMenu.isVisible();
}
private void renderUserInterface() {
for (UIDisplayElement screen : _guiScreens) {
screen.render();
}
}
private void updateUserInterface() {
for (UIDisplayElement screen : _guiScreens) {
screen.update();
}
}
public void pause() {
_pauseGame = true;
}
public void unpause() {
_pauseGame = false;
}
public void togglePauseGame() {
if (_pauseGame) {
unpause();
} else {
pause();
}
}
private void toggleInventory() {
if (screenCanFocus(_inventoryScreen))
_inventoryScreen.setVisible(!_inventoryScreen.isVisible());
}
public void togglePauseMenu() {
if (screenCanFocus(_pauseMenu))
_pauseMenu.setVisible(!_pauseMenu.isVisible());
}
public void toggleViewingDistance() {
_activeViewingDistance = (_activeViewingDistance + 1) % 4;
_activeWorldRenderer.setViewingDistance(VIEWING_DISTANCES[_activeViewingDistance]);
>>>>>>>
getGameMode().update();
<<<<<<<
=======
/*
* Process mouse input - nothing system-y, so just passing it to the Player class
*/
private void processMouseInput() {
while (Mouse.next()) {
int button = Mouse.getEventButton();
int wheelMoved = Mouse.getEventDWheel();
for (UIDisplayElement screen : _guiScreens) {
if (screenCanFocus(screen)) {
screen.processMouseInput(button, Mouse.getEventButtonState(), wheelMoved);
}
}
if (!screenHasFocus())
_activeWorldRenderer.getPlayer().processMouseInput(button, Mouse.getEventButtonState(), wheelMoved);
}
}
/**
* Process keyboard input - first look for "system" like events, then otherwise pass to the Player object
*/
private void processKeyboardInput() {
boolean debugEnabled = (Boolean) ConfigurationManager.getInstance().getConfig().get("System.Debug.debug");
while (Keyboard.next()) {
int key = Keyboard.getEventKey();
if (!Keyboard.isRepeatEvent() && Keyboard.getEventKeyState()) {
if (key == Keyboard.KEY_ESCAPE) {
togglePauseMenu();
}
if (key == Keyboard.KEY_I) {
toggleInventory();
}
if (key == Keyboard.KEY_F3) {
ConfigurationManager.getInstance().getConfig().put("System.Debug.debug", debugEnabled = !(debugEnabled));
}
if (key == Keyboard.KEY_F) {
toggleViewingDistance();
}
// Pass input to focused GUI element
for (UIDisplayElement screen : _guiScreens) {
if (screenCanFocus(screen)) {
screen.processKeyboardInput(key);
}
}
}
// Features for debug mode only
if (debugEnabled) {
if (key == Keyboard.KEY_UP && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() + 0.005);
}
if (key == Keyboard.KEY_DOWN && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() - 0.005);
}
if (key == Keyboard.KEY_RIGHT && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() + 0.02);
}
if (key == Keyboard.KEY_LEFT && Keyboard.getEventKeyState()) {
getActiveWorldProvider().setTime(getActiveWorldProvider().getTime() - 0.02);
}
}
// Pass input to the current player
if (!screenHasFocus())
_activeWorldRenderer.getPlayer().processKeyboardInput(key, Keyboard.getEventKeyState(), Keyboard.isRepeatEvent());
}
}
>>>>>>>
<<<<<<<
public WorldProvider getActiveWorldProvider() {
return getGameMode().getActiveWorldRenderer().getWorldProvider();
=======
public IWorldProvider getActiveWorldProvider() {
return _activeWorldRenderer.getWorldProvider();
>>>>>>>
public IWorldProvider getActiveWorldProvider() {
return getGameMode().getActiveWorldRenderer().getWorldProvider(); |
<<<<<<<
public void spawnTest() {
Player player = Terasology.getInstance().getActiveWorldRenderer().getPlayer();
GelatinousCubeFactory factory = new GelatinousCubeFactory();
factory.setEntityManager(Terasology.getInstance().getCurrentGameState().getEntityManager());
factory.setRandom(Terasology.getInstance().getActiveWorldRenderer().getWorldProvider().getRandom());
factory.generateGelatinousCube(new Vector3f((float)player.getPosition().x, (float)player.getPosition().y, (float)player.getPosition().z));
}
=======
public void gotoWorld(String title) {
IGameState state = Terasology.getInstance().getCurrentGameState();
if (state instanceof StateSinglePlayer) {
StateSinglePlayer spState = (StateSinglePlayer) state;
spState.initWorld(title);
}
}
public void gotoWorld(String title, String seed) {
IGameState state = Terasology.getInstance().getCurrentGameState();
if (state instanceof StateSinglePlayer) {
StateSinglePlayer spState = (StateSinglePlayer) state;
spState.initWorld(title, seed);
}
}
>>>>>>>
public void spawnTest() {
Player player = Terasology.getInstance().getActiveWorldRenderer().getPlayer();
GelatinousCubeFactory factory = new GelatinousCubeFactory();
factory.setEntityManager(Terasology.getInstance().getCurrentGameState().getEntityManager());
factory.setRandom(Terasology.getInstance().getActiveWorldRenderer().getWorldProvider().getRandom());
factory.generateGelatinousCube(new Vector3f((float)player.getPosition().x, (float)player.getPosition().y, (float)player.getPosition().z));
}
public void gotoWorld(String title) {
IGameState state = Terasology.getInstance().getCurrentGameState();
if (state instanceof StateSinglePlayer) {
StateSinglePlayer spState = (StateSinglePlayer) state;
spState.initWorld(title);
}
}
public void gotoWorld(String title, String seed) {
IGameState state = Terasology.getInstance().getCurrentGameState();
if (state instanceof StateSinglePlayer) {
StateSinglePlayer spState = (StateSinglePlayer) state;
spState.initWorld(title, seed);
}
} |
<<<<<<<
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import org.lwjgl.opengl.GL13;
=======
import org.lwjgl.opengl.GL11;
>>>>>>>
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import org.lwjgl.opengl.GL13;
<<<<<<<
/*Stars*/
public static IntBuffer textureId = BufferUtils.createIntBuffer(1);
public static IntBuffer textureCloudsId = BufferUtils.createIntBuffer(1);
=======
>>>>>>>
/*Stars*/
public static IntBuffer textureId = BufferUtils.createIntBuffer(1);
public static IntBuffer textureCloudsId = BufferUtils.createIntBuffer(1);
<<<<<<<
glEnable(GL13.GL_TEXTURE_CUBE_MAP);
glEnable(GL12.GL_TEXTURE_3D);
GL11.glBindTexture(GL13.GL_TEXTURE_CUBE_MAP, textureId.get(0));
GL11.glBindTexture(GL12.GL_TEXTURE_3D, textureCloudsId.get(0));
// GL11.glTexParameteri ( GL12.GL_TEXTURE_3D, EXTTextureFilterAnisotropic.GL_TEXTURE_MAX_ANISOTROPY_EXT, 8 );
//float sunPosInRadians = (float)Math.toRadians(180*(_time-0.075));
_sunPosAngle = 5.3f * (float) _parent.getTime() - 1.4f;
=======
_sunPosAngle = (float) Math.toRadians(360.0 * _parent.getTime() - 90.0);
>>>>>>>
glEnable(GL13.GL_TEXTURE_CUBE_MAP);
glEnable(GL12.GL_TEXTURE_3D);
GL11.glBindTexture(GL13.GL_TEXTURE_CUBE_MAP, textureId.get(0));
GL11.glBindTexture(GL12.GL_TEXTURE_3D, textureCloudsId.get(0));
// GL11.glTexParameteri ( GL12.GL_TEXTURE_3D, EXTTextureFilterAnisotropic.GL_TEXTURE_MAX_ANISOTROPY_EXT, 8 );
//float sunPosInRadians = (float)Math.toRadians(180*(_time-0.075));
_sunPosAngle = (float) Math.toRadians(360.0 * _parent.getTime() - 90.0); |
<<<<<<<
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
import org.terasology.engine.bootstrap.EntitySystemSetupUtil;
=======
import org.terasology.assets.ResourceUrn;
import org.terasology.assets.management.AssetManager;
import org.terasology.assets.module.ModuleAwareAssetTypeManager;
import org.terasology.engine.bootstrap.EntitySystemBuilder;
>>>>>>>
import org.terasology.context.Context;
import org.terasology.context.internal.ContextImpl;
import org.terasology.engine.bootstrap.EntitySystemSetupUtil;
import org.terasology.assets.ResourceUrn;
import org.terasology.assets.management.AssetManager;
import org.terasology.assets.module.ModuleAwareAssetTypeManager;
<<<<<<<
context = new ContextImpl();
ModuleManager moduleManager = ModuleManagerFactory.create();
context.put(ModuleManager.class, moduleManager);
AssetManager assetManager = new AssetManagerImpl(moduleManager.getEnvironment());
assetManager.setAssetFactory(AssetType.PREFAB, new AssetFactory<PrefabData, Prefab>() {
@Override
public Prefab buildAsset(AssetUri uri, PrefabData data) {
return new PojoPrefab(uri, data);
}
});
context.put(AssetManager.class, assetManager);
CoreRegistry.setContext(context);
=======
moduleManager = ModuleManagerFactory.create();
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.registerCoreAssetType(Prefab.class, PojoPrefab::new, "prefabs");
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
CoreRegistry.put(AssetManager.class, assetTypeManager.getAssetManager());
>>>>>>>
context = new ContextImpl();
ModuleManager moduleManager = ModuleManagerFactory.create();
context.put(ModuleManager.class, moduleManager);
ModuleAwareAssetTypeManager assetTypeManager = new ModuleAwareAssetTypeManager();
assetTypeManager.registerCoreAssetType(Prefab.class, PojoPrefab::new, "prefabs");
assetTypeManager.switchEnvironment(moduleManager.getEnvironment());
context.put(AssetManager.class, assetTypeManager.getAssetManager());
CoreRegistry.setContext(context); |
<<<<<<<
=======
import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
import static org.lwjgl.opengl.GL11.glClear;
import static org.lwjgl.opengl.GL11.glLoadIdentity;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.vecmath.Vector3f;
import org.lwjgl.input.Mouse;
>>>>>>> |
<<<<<<<
final UIImageOverlay overlay;
final UIList list;
final UIButton goToBack;
final UIButton createNewWorld;
final UIButton loadFromList;
final UIButton deleteFromList;
final UIDialogCreateNewWorld window;
=======
final UIImageOverlay _overlay;
final UIList _list;
final UIButton _goToBack;
final UIButton _createNewWorld;
final UIButton _loadFromList;
final UIButton _deleteFromList;
>>>>>>>
final UIImageOverlay overlay;
final UIList list;
final UIButton goToBack;
final UIButton createNewWorld;
final UIButton loadFromList;
final UIButton deleteFromList;
<<<<<<<
window = new UIDialogCreateNewWorld("Create new world", new Vector2f(512f, 320f));
window.center();
window.setModal(true);
GUIManager.getInstance().addWindow(window, "generate_world");
list = new UIList(new Vector2f(512f, 256f));
list.setVisible(true);
=======
_list = new UIList(new Vector2f(512f, 256f));
_list.setVisible(true);
>>>>>>>
list = new UIList(new Vector2f(512f, 256f));
list.setVisible(true);
<<<<<<<
GUIManager.getInstance().setFocusedWindow(window);
window.clearInputControls();
UIInput inputWorldName = (UIInput) window.getElementById("inputWorldTitle");
inputWorldName.setValue(window.getWorldName());
=======
UIDialogCreateNewWorld _window = new UIDialogCreateNewWorld("Create new world", new Vector2f(512f, 320f));
_window.center();
_window.clearInputControls();
GUIManager.getInstance().addWindow(_window, "generate_world");
GUIManager.getInstance().setFocusedWindow(_window);
UIInput inputWorldName = (UIInput) _window.getElementById("inputWorldTitle");
inputWorldName.setValue(_window.getWorldName());
>>>>>>>
UIDialogCreateNewWorld _window = new UIDialogCreateNewWorld("Create new world", new Vector2f(512f, 320f));
_window.center();
_window.clearInputControls();
GUIManager.getInstance().addWindow(_window, "generate_world");
GUIManager.getInstance().setFocusedWindow(_window);
UIInput inputWorldName = (UIInput) _window.getElementById("inputWorldTitle");
inputWorldName.setValue(_window.getWorldName()); |
<<<<<<<
import com.google.common.collect.SetMultimap;
=======
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
>>>>>>>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.SetMultimap;
<<<<<<<
private SetMultimap<AssetUri, URL> assets = HashMultimap.create();
private SetMultimap<AssetType, AssetUri> assetsByType = HashMultimap.create();
=======
private Multimap<AssetUri, URL> assets = HashMultimap.create();
private Multimap<AssetType, AssetUri> assetsByType = HashMultimap.create();
private Multimap<AssetUri, URL> overrides = HashMultimap.create();
>>>>>>>
private SetMultimap<AssetUri, URL> assets = HashMultimap.create();
private SetMultimap<AssetType, AssetUri> assetsByType = HashMultimap.create();
private SetMultimap<AssetUri, URL> overrides = HashMultimap.create(); |
<<<<<<<
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.nio.ByteBuffer;
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
import static org.lwjgl.opengl.GL11.GL_LEQUAL;
import static org.lwjgl.opengl.GL11.GL_NORMALIZE;
import static org.lwjgl.opengl.GL11.glDepthFunc;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL11.glViewport;
=======
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.nio.ByteBuffer;
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
import static org.lwjgl.opengl.GL11.GL_LEQUAL;
import static org.lwjgl.opengl.GL11.GL_NORMALIZE;
import static org.lwjgl.opengl.GL11.glDepthFunc;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL11.glViewport;
public class LwjglGraphics extends BaseLwjglSubsystem {
>>>>>>>
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.nio.ByteBuffer;
import static org.lwjgl.opengl.GL11.GL_CULL_FACE;
import static org.lwjgl.opengl.GL11.GL_DEPTH_TEST;
import static org.lwjgl.opengl.GL11.GL_LEQUAL;
import static org.lwjgl.opengl.GL11.GL_NORMALIZE;
import static org.lwjgl.opengl.GL11.glDepthFunc;
import static org.lwjgl.opengl.GL11.glEnable;
import static org.lwjgl.opengl.GL11.glViewport;
<<<<<<<
public void postInitialise(Context context) {
context.put(RenderingSubsystemFactory.class, new LwjglRenderingSubsystemFactory(bufferPool));
=======
public void initialise(Config config) {
}
@Override
public void registerCoreAssetTypes(ModuleAwareAssetTypeManager assetTypeManager) {
assetTypeManager.registerCoreAssetType(Font.class, FontImpl::new, "fonts");
assetTypeManager.registerCoreAssetType(Texture.class, OpenGLTexture::new, "textures", "fonts");
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.NEAREST, path -> path.getName(1).toString().equals("textures")));
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.LINEAR, path -> path.getName(1).toString().equals("fonts")));
assetTypeManager.registerCoreAssetType(Shader.class, GLSLShader::new, "shaders");
assetTypeManager.registerCoreAssetType(Material.class, GLSLMaterial::new, "materials");
assetTypeManager.registerCoreAssetType(Mesh.class, (urn, assetType, data) -> new OpenGLMesh(urn, assetType, bufferPool, data), "mesh");
assetTypeManager.registerCoreAssetType(SkeletalMesh.class, (urn, assetType, data) -> new OpenGLSkeletalMesh(urn, assetType, data, bufferPool), "skeletalMesh");
assetTypeManager.registerCoreAssetType(MeshAnimation.class, MeshAnimationImpl::new, "animations");
assetTypeManager.registerCoreAssetType(Atlas.class, Atlas::new, "atlas");
assetTypeManager.registerCoreAssetType(Subtexture.class, Subtexture::new);
}
@Override
public void postInitialise(Config config) {
CoreRegistry.putPermanently(RenderingSubsystemFactory.class, new LwjglRenderingSubsystemFactory(bufferPool));
>>>>>>>
public void initialise(Context context) {
}
@Override
public void registerCoreAssetTypes(ModuleAwareAssetTypeManager assetTypeManager) {
assetTypeManager.registerCoreAssetType(Font.class, FontImpl::new, "fonts");
assetTypeManager.registerCoreAssetType(Texture.class, OpenGLTexture::new, "textures", "fonts");
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.NEAREST, path -> path.getName(1).toString().equals("textures")));
assetTypeManager.registerCoreFormat(Texture.class, new PNGTextureFormat(Texture.FilterMode.LINEAR, path -> path.getName(1).toString().equals("fonts")));
assetTypeManager.registerCoreAssetType(Shader.class, GLSLShader::new, "shaders");
assetTypeManager.registerCoreAssetType(Material.class, GLSLMaterial::new, "materials");
assetTypeManager.registerCoreAssetType(Mesh.class, (urn, assetType, data) -> new OpenGLMesh(urn, assetType, bufferPool, data), "mesh");
assetTypeManager.registerCoreAssetType(SkeletalMesh.class, (urn, assetType, data) -> new OpenGLSkeletalMesh(urn, assetType, data, bufferPool), "skeletalMesh");
assetTypeManager.registerCoreAssetType(MeshAnimation.class, MeshAnimationImpl::new, "animations");
assetTypeManager.registerCoreAssetType(Atlas.class, Atlas::new, "atlas");
assetTypeManager.registerCoreAssetType(Subtexture.class, Subtexture::new);
}
@Override
public void postInitialise(Context context) {
context.put(RenderingSubsystemFactory.class, new LwjglRenderingSubsystemFactory(bufferPool));
<<<<<<<
AssetManager assetManager = context.get(AssetManager.class);
assetManager.setAssetFactory(AssetType.FONT, new AssetFactory<FontData, Font>() {
@Override
public Font buildAsset(AssetUri uri, FontData data) {
return new FontImpl(uri, data);
}
});
assetManager.setAssetFactory(AssetType.TEXTURE, new AssetFactory<TextureData, Texture>() {
@Override
public Texture buildAsset(AssetUri uri, TextureData data) {
return new OpenGLTexture(uri, data);
}
});
assetManager.setAssetFactory(AssetType.SHADER, new AssetFactory<ShaderData, Shader>() {
@Override
public Shader buildAsset(AssetUri uri, ShaderData data) {
return new GLSLShader(uri, data);
}
});
assetManager.setAssetFactory(AssetType.MATERIAL, new AssetFactory<MaterialData, Material>() {
@Override
public Material buildAsset(AssetUri uri, MaterialData data) {
return new GLSLMaterial(uri, data);
}
});
assetManager.setAssetFactory(AssetType.MESH, new AssetFactory<MeshData, Mesh>() {
@Override
public Mesh buildAsset(AssetUri uri, MeshData data) {
return new OpenGLMesh(uri, data, bufferPool);
}
});
assetManager.setAssetFactory(AssetType.SKELETON_MESH, new AssetFactory<SkeletalMeshData, SkeletalMesh>() {
@Override
public SkeletalMesh buildAsset(AssetUri uri, SkeletalMeshData data) {
return new OpenGLSkeletalMesh(uri, data, bufferPool);
}
});
assetManager.setAssetFactory(AssetType.ANIMATION, new AssetFactory<MeshAnimationData, MeshAnimation>() {
@Override
public MeshAnimation buildAsset(AssetUri uri, MeshAnimationData data) {
return new MeshAnimationImpl(uri, data);
}
});
assetManager.setAssetFactory(AssetType.ATLAS, new AssetFactory<AtlasData, Atlas>() {
@Override
public Atlas buildAsset(AssetUri uri, AtlasData data) {
return new Atlas(uri, data);
}
});
assetManager.setAssetFactory(AssetType.SUBTEXTURE, new AssetFactory<SubtextureData, Subtexture>() {
@Override
public Subtexture buildAsset(AssetUri uri, SubtextureData data) {
return new Subtexture(uri, data);
}
});
assetManager.addResolver(AssetType.SUBTEXTURE, new SubtextureFromAtlasResolver());
assetManager.addResolver(AssetType.TEXTURE, new ColorTextureAssetResolver());
assetManager.addResolver(AssetType.TEXTURE, new NoiseTextureAssetResolver());
assetManager.addResolver(AssetType.MESH, new IconMeshResolver());
context.put(ShaderManager.class, new ShaderManagerLwjgl());
=======
CoreRegistry.putPermanently(ShaderManager.class, new ShaderManagerLwjgl());
>>>>>>>
context.put(ShaderManager.class, new ShaderManagerLwjgl()); |
<<<<<<<
/*
* Copyright 2019 MovingBlocks
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.terasology.engine.config.flexible.internal;
=======
// Copyright 2021 The Terasology Foundation
// SPDX-License-Identifier: Apache-2.0
package org.terasology.config.flexible.internal;
>>>>>>>
// Copyright 2021 The Terasology Foundation
// SPDX-License-Identifier: Apache-2.0
package org.terasology.engine.config.flexible.internal; |
<<<<<<<
getListView().setCacheColorHint(0xffffff);
setListAdapter(listAdapter);
// handler = new IncomingHandler();
=======
setListAdapter(bufferListAdapter);
>>>>>>>
getListView().setCacheColorHint(0xffffff);
setListAdapter(listAdapter);
// handler = new IncomingHandler();
setListAdapter(bufferListAdapter); |
<<<<<<<
import com.google.common.base.Supplier;
=======
import java.util.Collections;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Provider;
>>>>>>>
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Provider;
<<<<<<<
import org.grouplens.lenskit.core.Builder;
=======
import org.grouplens.lenskit.RecommenderEngineFactory;
>>>>>>>
<<<<<<<
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Collections;
import java.util.Map;
=======
import com.google.common.base.Supplier;
>>>>>>>
import com.google.common.base.Supplier;
import java.util.Collections;
import java.util.Map;
<<<<<<<
// FIXME Bind this to a provider
Builder<RatingSnapshot> bld = new Builder<RatingSnapshot>() {
=======
fac2 = factory.clone();
Provider<RatingSnapshot> prv = new Provider<RatingSnapshot>() {
>>>>>>>
// FIXME Bind this to a provider
Provider<RatingSnapshot> prv = new Provider<RatingSnapshot>() {
<<<<<<<
=======
public Recommender buildRecommender(DataAccessObject dao, @Nullable RatingSnapshot sharedSnapshot) {
// Copy the factory & set up a shared rating snapshot
LenskitRecommenderEngineFactory fac2 = factory;
if (sharedSnapshot != null) {
fac2 = factory.clone();
fac2.bind(RatingSnapshot.class).to(sharedSnapshot);
}
LenskitRecommenderEngine engine = fac2.create(dao);
return engine.open(dao, false);
}
>>>>>>> |
<<<<<<<
import org.grouplens.lenskit.collections.LongSortedArraySet;
import org.junit.Test;
import com.google.common.collect.Iterators;
import com.google.common.collect.Sets;
=======
import static org.grouplens.lenskit.util.test.ExtraMatchers.notANumber;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
>>>>>>>
import static org.grouplens.lenskit.util.test.ExtraMatchers.notANumber;
import org.grouplens.lenskit.collections.LongSortedArraySet;
import org.junit.Test;
import com.google.common.collect.Iterators;
import com.google.common.collect.Sets; |
<<<<<<<
List<ScoredId> out = accum.finish();
assertThat(out.size(), equalTo(3));
assertThat(out.get(0).getId(), equalTo(2L));
assertThat(out.get(0).getScore(), equalTo(9.8));
assertThat(out.get(1).getId(), equalTo(5L));
assertThat(out.get(1).getScore(), equalTo(4.2));
assertThat(out.get(2).getId(), equalTo(3L));
assertThat(out.get(2).getScore(), equalTo(2.9));
=======
ScoredLongList out = accum.finish();
assertThat(out, hasSize(3));
assertThat(out.get(0), equalTo(2L));
assertThat(out.getScore(0), equalTo(9.8));
assertThat(out.get(1), equalTo(5L));
assertThat(out.getScore(1), equalTo(4.2));
assertThat(out.get(2), equalTo(3L));
assertThat(out.getScore(2), equalTo(2.9));
>>>>>>>
List<ScoredId> out = accum.finish();
assertThat(out, hasSize(3));
assertThat(out.get(0).getId(), equalTo(2L));
assertThat(out.get(0).getScore(), equalTo(9.8));
assertThat(out.get(1).getId(), equalTo(5L));
assertThat(out.get(1).getScore(), equalTo(4.2));
assertThat(out.get(2).getId(), equalTo(3L));
assertThat(out.get(2).getScore(), equalTo(2.9));
<<<<<<<
List<ScoredId> out = accum.finish();
assertThat(out.size(), equalTo(3));
assertThat(out.get(0).getId(), equalTo(2L));
assertThat(out.get(0).getScore(), equalTo(9.8));
assertThat(out.get(1).getId(), equalTo(5L));
assertThat(out.get(1).getScore(), equalTo(4.2));
assertThat(out.get(2).getId(), equalTo(3L));
assertThat(out.get(2).getScore(), equalTo(2.9));
=======
ScoredLongList out = accum.finish();
assertThat(out, hasSize(3));
assertThat(out.get(0), equalTo(2L));
assertThat(out.getScore(0), equalTo(9.8));
assertThat(out.get(1), equalTo(5L));
assertThat(out.getScore(1), equalTo(4.2));
assertThat(out.get(2), equalTo(3L));
assertThat(out.getScore(2), equalTo(2.9));
>>>>>>>
List<ScoredId> out = accum.finish();
assertThat(out, hasSize(3));
assertThat(out.get(0).getId(), equalTo(2L));
assertThat(out.get(0).getScore(), equalTo(9.8));
assertThat(out.get(1).getId(), equalTo(5L));
assertThat(out.get(1).getScore(), equalTo(4.2));
assertThat(out.get(2).getId(), equalTo(3L));
assertThat(out.get(2).getScore(), equalTo(2.9)); |
<<<<<<<
import org.grouplens.grapht.annotation.Transient;
=======
import it.unimi.dsi.fastutil.longs.LongIterator;
>>>>>>>
<<<<<<<
import org.grouplens.lenskit.data.dao.DataAccessObject;
=======
import org.grouplens.lenskit.collections.LongSortedArraySet;
import org.grouplens.lenskit.core.Transient;
>>>>>>>
import org.grouplens.lenskit.data.dao.DataAccessObject;
import org.grouplens.lenskit.core.Transient; |
<<<<<<<
* Removes all channels from new {@code ScoredId} objects produced by the builder.
* @return This builder (for chaining)
=======
* Add a new typed side channel to the {@code ScoredId} under construction.
* @param s The symbol for the side channel.
* @param value The value for the side channel.
* @return This builder (for chaining)
*/
public <K> ScoredIdBuilder addChannel(TypedSymbol<K> s, K value) {
typedChannelMap.put(s, value);
return this;
}
/**
* Removes all channels (typed and double) from new {@code ScoredId} objects produced by the builder.
>>>>>>>
* Add a new typed side channel to the {@code ScoredId} under construction.
* @param s The symbol for the side channel.
* @param value The value for the side channel.
* @return This builder (for chaining)
*/
public <K> ScoredIdBuilder addChannel(TypedSymbol<K> s, K value) {
typedChannelMap.put(s, value);
return this;
}
/**
* Removes all channels (typed and double) from new {@code ScoredId} objects produced by the builder.
* @return This builder (for chaining)
<<<<<<<
return this;
=======
typedChannelMap.clear();
>>>>>>>
typedChannelMap.clear();
return this; |
<<<<<<<
public GlobalMeanPredictor build() {
double avg = computeMeanRating(context.getRatings().fastIterator());
=======
protected GlobalMeanPredictor buildNew(RatingBuildContext context) {
double avg = computeMeanRating(context.ratingSnapshot().getRatings().fastIterator());
>>>>>>>
public GlobalMeanPredictor build() {
double avg = computeMeanRating(context.ratingSnapshot().getRatings().fastIterator()); |
<<<<<<<
LongSet candidates = getCandidateSelector().selectItems(allItems, recommender, testUser);
LongSet excludes = getExcludeSelector().selectItems(allItems, recommender, testUser);
ResultList results = itemRecommender.recommendWithDetails(testUser.getUserId(), getListSize(),
candidates, excludes);
=======
LongSet candidates = getCandidateSelector().selectItems(allItems, testUser);
LongSet excludes = getExcludeSelector().selectItems(allItems, testUser);
int n = getListSize();
ResultList results = recommender.recommendWithDetails(testUser.getUserId(), n,
candidates, excludes);
>>>>>>>
LongSet candidates = getCandidateSelector().selectItems(allItems, recommender, testUser);
LongSet excludes = getExcludeSelector().selectItems(allItems, recommender, testUser);
int n = getListSize();
ResultList results = itemRecommender.recommendWithDetails(testUser.getUserId(), n,
candidates, excludes); |
<<<<<<<
import org.grouplens.lenskit.data.pref.PreferenceDomain;
=======
import java.io.Serializable;
import javax.inject.Inject;
import org.grouplens.lenskit.params.MaxRating;
import org.grouplens.lenskit.params.MinRating;
>>>>>>>
import org.grouplens.lenskit.data.pref.PreferenceDomain;
import javax.inject.Inject;
import org.grouplens.lenskit.params.MaxRating;
import org.grouplens.lenskit.params.MinRating;
<<<<<<<
public RatingRangeClamp(double min, double max) {
this(new PreferenceDomain(min, max));
=======
@Inject
public RatingRangeClamp(@MinRating double min, @MaxRating double max) {
minRating = min;
maxRating = max;
>>>>>>>
@Inject
public RatingRangeClamp(@MinRating double min, @MaxRating double max) {
this(new PreferenceDomain(min, max)); |
<<<<<<<
public MetricResult measureUser(TestUser user, ResultList recs, Context context) {
LongSet good = goodItems.selectItems(context.universe, context.recommender, user);
=======
public MetricResult measureUser(TestUser user, int targetLength, ResultList recs, Context context) {
LongSet good = goodItems.selectItems(context.universe, user);
>>>>>>>
public MetricResult measureUser(TestUser user, int targetLength, ResultList recs, Context context) {
LongSet good = goodItems.selectItems(context.universe, context.recommender, user); |
<<<<<<<
import java.util.BitSet;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
=======
import java.util.*;
import java.util.Map.Entry;
>>>>>>>
import java.util.BitSet;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
<<<<<<<
@SuppressFBWarnings(value="SE_BAD_FIELD", justification="stored value is always serializable")
private final Map<Symbol, MutableSparseVector> channelMap;
=======
// It is possible for objects of this type to be converted to an
// ImmutableSparseVector. For efficiency, rather than copy the
// data, we can "freeze" this implementation so it can no longer
// be changed. Setting this variable to be false causes all
// mutation methods to throw an exception if they are called.
protected boolean isMutable = true;
private Map<Symbol, MutableSparseVector> channelMap;
private Map<TypedSymbol<?>, TypedSideChannel<?>> typedChannelMap;
>>>>>>>
@SuppressFBWarnings(value="SE_BAD_FIELD", justification="stored value is always serializable")
private final Map<Symbol, MutableSparseVector> channelMap;
@SuppressFBWarnings(value="SE_BAD_FIELD", justification="stored value is always serializable")
private final Map<TypedSymbol<?>, TypedSideChannel<?>> typedChannelMap; |
<<<<<<<
import org.grouplens.lenskit.util.TaskTimer;
=======
import org.grouplens.lenskit.eval.metrics.predict.PredictEvalMetric.Accumulator;
>>>>>>>
<<<<<<<
TaskTimer testTimer = new TaskTimer();
List<PredictEvalAccumulator> evalAccums =
new ArrayList<PredictEvalAccumulator>(evaluators.size());
=======
StopWatch testTimer = new StopWatch();
testTimer.start();
List<Accumulator> evalAccums =
new ArrayList<Accumulator>(evaluators.size());
>>>>>>>
StopWatch testTimer = new StopWatch();
testTimer.start();
List<PredictEvalAccumulator> evalAccums =
new ArrayList<PredictEvalAccumulator>(evaluators.size());
<<<<<<<
private void writeOutput(TaskTimer build, TaskTimer test, List<PredictEvalAccumulator> accums) throws IOException {
=======
private void writeOutput(StopWatch build, StopWatch test, List<Accumulator> accums) throws IOException {
>>>>>>>
private void writeOutput(StopWatch build, StopWatch test, List<PredictEvalAccumulator> accums) throws IOException { |
<<<<<<<
import org.grouplens.lenskit.eval.metrics.TestUserMetric;
import org.grouplens.lenskit.util.tablewriter.*;
=======
import org.grouplens.lenskit.eval.metrics.EvalMetric;
import org.grouplens.lenskit.util.tablewriter.CSVWriter;
import org.grouplens.lenskit.util.tablewriter.TableLayout;
import org.grouplens.lenskit.util.tablewriter.TableLayoutBuilder;
import org.grouplens.lenskit.util.tablewriter.TableWriter;
import org.grouplens.lenskit.util.tablewriter.TableWriters;
>>>>>>>
import org.grouplens.lenskit.eval.metrics.TestUserMetric;
import org.grouplens.lenskit.util.tablewriter.CSVWriter;
import org.grouplens.lenskit.util.tablewriter.TableLayout;
import org.grouplens.lenskit.util.tablewriter.TableLayoutBuilder;
import org.grouplens.lenskit.util.tablewriter.TableWriter;
import org.grouplens.lenskit.util.tablewriter.TableWriters;
<<<<<<<
private List<TTDataSet> dataSources;
private List<AlgorithmInstance> algorithms;
private List<TestUserMetric> metrics;
private IsolationLevel isolationLevel;
=======
private final List<TTDataSet> dataSources;
private final List<AlgorithmInstance> algorithms;
private final List<EvalMetric> metrics;
private final IsolationLevel isolationLevel;
>>>>>>>
private final List<TTDataSet> dataSources;
private final List<AlgorithmInstance> algorithms;
private List<TestUserMetric> metrics;
private final IsolationLevel isolationLevel; |
<<<<<<<
List<TestUserMetric> evals,
TTDataSet data) {
=======
List<EvalMetric> evals,
TTDataSet data,
int numRecs) {
>>>>>>>
List<TestUserMetric> evals,
TTDataSet data,
int numRecs) { |
<<<<<<<
double globalMean = computeItemAverages(context.getRatings().fastIterator(), damping, itemMeans);
=======
double globalMean = computeItemAverages(context.ratingSnapshot().getRatings().fastIterator(), smoothing, itemMeans);
>>>>>>>
double globalMean = computeItemAverages(context.ratingSnapshot().getRatings().fastIterator(), damping, itemMeans); |
<<<<<<<
import org.grouplens.lenskit.vectors.Vectors;
=======
import org.grouplens.lenskit.vectors.VectorEntry;
>>>>>>>
import org.grouplens.lenskit.vectors.Vectors;
import org.grouplens.lenskit.vectors.VectorEntry;
<<<<<<<
int nCoratings = 0;
for (Vectors.EntryPair pair : Vectors.pairedFast(vec1, vec2)) {
final double v1 = pair.getValue1() - mu1;
final double v2 = pair.getValue2() - mu2;
var1 += v1 * v1;
var2 += v2 * v2;
dot += v1 * v2;
nCoratings += 1;
}
=======
int nCoratings = 0; // number of common items rated
Iterator<VectorEntry> it1 = vec1.fastIterator();
Iterator<VectorEntry> it2 = vec2.fastIterator();
VectorEntry e1 = it1.next();
VectorEntry e2 = it2.next();
do {
/* Do one step of the parallel walk. If the two entries have the
* same key, add to the accumulators and advance both. Otherwise,
* advance the one further back to try to catch up.
*/
// TODO Fix this loop to have cleaner hasNext/next pairs
if (e1.getKey() == e2.getKey()) {
final double v1 = e1.getValue() - mu1;
final double v2 = e2.getValue() - mu2;
var1 += v1 * v1;
var2 += v2 * v2;
dot += v1 * v2;
nCoratings += 1;
if (it1.hasNext()) {
e1 = it1.next();
}
if (it2.hasNext()) {
e2 = it2.next();
}
} else if (e1.getKey() < e2.getKey()) {
if (it1.hasNext()) {
e1 = it1.next();
}
} else {
if (it2.hasNext()) {
e2 = it2.next();
}
}
} while (it1.hasNext() && it2.hasNext());
>>>>>>>
int nCoratings = 0;
for (Vectors.EntryPair pair : Vectors.pairedFast(vec1, vec2)) {
final double v1 = pair.getValue1() - mu1;
final double v2 = pair.getValue2() - mu2;
var1 += v1 * v1;
var2 += v2 * v2;
dot += v1 * v2;
nCoratings += 1;
} |
<<<<<<<
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
=======
import com.google.common.base.Function;
>>>>>>>
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
<<<<<<<
=======
public void setSplitUsers(boolean splitUsers) {
this.splitUsers = splitUsers;
}
private CrossfoldCommand initialize() {
String path = new File(getConfig().getDataDir(), name).getPath();
if (trainFilePattern == null) {
trainFilePattern = path + ".train.%d.csv";
}
if (testFilePattern == null) {
testFilePattern = path + ".test.%d.csv";
}
holdout = new Holdout(order, partition);
return this;
}
>>>>>>>
public void setSplitUsers(boolean splitUsers) {
this.splitUsers = splitUsers;
}
<<<<<<<
protected void createTTFiles(DataAccessObject dao, Holdout mode, Long2IntMap splits) throws CommandException {
File[] trainFiles = getFiles(getTrainPattern());
File[] testFiles = getFiles(getTestPattern());
=======
protected void createTTFiles() throws CommandException {
File[] trainFiles = getFiles(trainFilePattern);
File[] testFiles = getFiles(testFilePattern);
>>>>>>>
protected void createTTFiles() throws CommandException {
File[] trainFiles = getFiles(getTrainPattern());
File[] testFiles = getFiles(getTestPattern()); |
<<<<<<<
import org.grouplens.lenskit.util.LKFileUtils;
import org.grouplens.lenskit.util.tablewriter.CSVWriter;
import org.grouplens.lenskit.util.tablewriter.TableLayout;
import org.grouplens.lenskit.util.tablewriter.TableLayoutBuilder;
import org.grouplens.lenskit.util.tablewriter.TableWriter;
import org.grouplens.lenskit.util.tablewriter.TableWriters;
=======
import org.grouplens.lenskit.util.tablewriter.*;
>>>>>>>
import org.grouplens.lenskit.util.tablewriter.CSVWriter;
import org.grouplens.lenskit.util.tablewriter.TableLayout;
import org.grouplens.lenskit.util.tablewriter.TableLayoutBuilder;
import org.grouplens.lenskit.util.tablewriter.TableWriter;
import org.grouplens.lenskit.util.tablewriter.TableWriters;
<<<<<<<
private final List<TTDataSet> dataSources;
private final List<AlgorithmInstance> algorithms;
private final List<EvalMetric> metrics;
=======
private List<TTDataSet> dataSources;
private List<AlgorithmInstance> algorithms;
private List<EvalMetric> metrics;
private IsolationLevel isolationLevel;
>>>>>>>
private final List<TTDataSet> dataSources;
private final List<AlgorithmInstance> algorithms;
private final List<EvalMetric> metrics;
private final IsolationLevel isolationLevel;
<<<<<<<
@Nullable File predictOutput,
int numRecs) {
=======
@Nullable File predictOutput,
IsolationLevel isolation) {
>>>>>>>
@Nullable File predictOutput,
IsolationLevel isolation,
int numRecs) { |
<<<<<<<
import org.grouplens.lenskit.data.context.PackedRatingBuildContext;
import org.grouplens.lenskit.data.context.PackedRatingSnapshot;
import org.grouplens.lenskit.data.context.RatingBuildContext;
=======
import org.grouplens.lenskit.data.context.PackedRatingBuildContext;
import org.grouplens.lenskit.data.context.RatingBuildContext;
>>>>>>>
import org.grouplens.lenskit.data.context.PackedRatingBuildContext;
import org.grouplens.lenskit.data.context.PackedRatingSnapshot;
import org.grouplens.lenskit.data.context.RatingBuildContext;
<<<<<<<
RatingBuildContext context;
=======
RatingBuildContext rs;
>>>>>>>
RatingBuildContext rs;
<<<<<<<
dao = new RatingCollectionDAO.Manager(ratings).open();
PackedRatingSnapshot rs = new PackedRatingSnapshot.Builder(dao).build();
context = new PackedRatingBuildContext(dao, rs);
=======
dao = new RatingCollectionDAO(ratings);
dao.openSession();
rs = PackedRatingBuildContext.make(dao);
>>>>>>>
dao = new RatingCollectionDAO.Manager(ratings).open();
PackedRatingSnapshot rs = new PackedRatingSnapshot.Builder(dao).build();
this.rs = new PackedRatingBuildContext(dao, rs);
builder.setRatingBuildContext(this.rs);
<<<<<<<
context.close();
dao.close();
=======
rs.close();
dao.closeSession();
}
@Test
public void testBuilderNoSmoothing() {
UserVarianceNormalizer urvn = builder.build(rs);
Assert.assertEquals(0.0, urvn.globalVariance, 0.0);
}
@Test
public void testBuilderSmoothing() {
builder.setSmoothing(3);
UserVarianceNormalizer urvn = builder.build(rs);
Assert.assertEquals(3.0, urvn.smoothing, 0.0);
Assert.assertEquals(2.0, urvn.globalVariance, MIN_DOUBLE_PRECISION);
>>>>>>>
rs.close();
dao.close();
}
@Test
public void testBuilderNoSmoothing() {
UserVarianceNormalizer urvn = builder.build();
Assert.assertEquals(0.0, urvn.getGlobalVariance(), 0.0);
}
@Test
public void testBuilderSmoothing() {
builder.setSmoothing(3);
UserVarianceNormalizer urvn = builder.build();
Assert.assertEquals(3.0, urvn.getSmoothing(), 0.0);
Assert.assertEquals(2.0, urvn.getGlobalVariance(), MIN_DOUBLE_PRECISION);
<<<<<<<
public void testSmoothing() {
UserVarianceNormalizer.Builder builder = new UserVarianceNormalizer.Builder();
builder.setRatingBuildContext(context);
builder.setSmoothing(3.0);
UserVarianceNormalizer urvn = builder.build();
=======
public void testSmoothingDetailed() {
UserVarianceNormalizer urvn;
builder.setSmoothing(3);
urvn = builder.build(rs);
>>>>>>>
public void testSmoothingDetailed() {
builder.setSmoothing(3.0);
UserVarianceNormalizer urvn = builder.build(); |
<<<<<<<
import it.unimi.dsi.fastutil.longs.AbstractLongComparator;
import it.unimi.dsi.fastutil.longs.Long2DoubleMap;
import it.unimi.dsi.fastutil.longs.LongArrayList;
import it.unimi.dsi.fastutil.longs.LongArrays;
import it.unimi.dsi.fastutil.longs.LongComparator;
import it.unimi.dsi.fastutil.longs.LongSortedSet;
import java.util.Iterator;
=======
import it.unimi.dsi.fastutil.longs.*;
>>>>>>>
import it.unimi.dsi.fastutil.longs.AbstractLongComparator;
import it.unimi.dsi.fastutil.longs.LongArrayList;
import it.unimi.dsi.fastutil.longs.LongArrays;
import it.unimi.dsi.fastutil.longs.LongComparator;
import it.unimi.dsi.fastutil.longs.LongSortedSet;
import java.util.Iterator;
<<<<<<<
for (Vectors.EntryPair pair : Vectors.pairedFast(this, o)) {
dot += pair.getValue1() * pair.getValue2();
=======
Pointer<VectorEntry> p1 = CollectionUtils.pointer(fastIterator());
Pointer<VectorEntry> p2 = CollectionUtils.pointer(o.fastIterator());
while (!p1.isAtEnd() && !p2.isAtEnd()) {
final long k1 = p1.get().getKey();
final long k2 = p2.get().getKey();
if (k1 == k2) {
dot += p1.get().getValue() * p2.get().getValue();
p1.advance();
p2.advance();
} else if (k1 < k2) {
p1.advance();
} else {
p2.advance();
}
>>>>>>>
for (Vectors.EntryPair pair : Vectors.pairedFast(this, o)) {
dot += pair.getValue1() * pair.getValue2();
<<<<<<<
for (Vectors.EntryPair pair : Vectors.pairedFast(this, o)) {
n++;
=======
Pointer<VectorEntry> p1 = CollectionUtils.pointer(fastIterator());
Pointer<VectorEntry> p2 = CollectionUtils.pointer(o.fastIterator());
while (!p1.isAtEnd() && !p2.isAtEnd()) {
final long k1 = p1.get().getKey();
final long k2 = p2.get().getKey();
if (k1 == k2) {
n++;
p1.advance();
p2.advance();
} else if (k1 < k2) {
p1.advance();
} else {
p2.advance();
}
>>>>>>>
for (Vectors.EntryPair pair : Vectors.pairedFast(this, o)) {
n++; |
<<<<<<<
=======
import org.grouplens.lenskit.data.context.RatingSnapshot;
>>>>>>>
<<<<<<<
=======
/**
* @param smoothing smoothing factor to use. 0 for no smoothing, 5 for Hofmann's implementation.
* @param ratings used to calculate global variance for use in smoothing calculations.
*/
public UserVarianceNormalizer(double smoothing, RatingSnapshot ratings) {
this.smoothing = smoothing;
// Don't bother wasting cycles if not smoothing
if (smoothing == 0) {
this.globalVariance = 0;
return;
}
double mean = 0;
double variance = 0;
double sum = 0;
Collection<IndexedRating> fastRatings = ratings.getRatings();
int numRatings = fastRatings.size();
for (IndexedRating rating : fastRatings) {
sum += rating.getRating();
}
mean = sum / numRatings;
sum = 0;
for (IndexedRating rating : fastRatings) {
sum += Math.pow(mean - rating.getRating(), 2);
}
variance = sum / numRatings;
this.globalVariance = variance;
}
>>>>>>> |
<<<<<<<
import org.grouplens.lenskit.norm.NormalizedRatingBuildContext;
import org.grouplens.lenskit.norm.UserRatingVectorNormalizer;
import org.grouplens.lenskit.util.FastCollection;
=======
import org.grouplens.lenskit.data.dao.RatingDataSession;
>>>>>>>
<<<<<<<
/**
* Return the dao that is backing this RatingBuildContext.
* @return
*/
RatingDataAccessObject getDAO();
/**
* Get the set of user IDs in the snapshot.
* @return A set of all known user IDs.
*/
LongCollection getUserIds();
/**
* Get the set of item IDs in the snapshot.
* @return A set of all known item IDs.
*/
LongCollection getItemIds();
/**
* Get the user ID index.
* @return The index mapping between user IDs and user indices.
*/
Index userIndex();
/**
* Get the item ID index.
* @return The index mapping between user IDs and user indices.
*/
Index itemIndex();
/**
* Get the collection of ratings in the snapshot. The ratings are returned
* in an undetermined order. It is guaranteed that no duplicate ratings
* appear - each <i>(user,item)</i> pair is rated at most once.
* @return All ratings in the system.
*/
FastCollection<IndexedRating> getRatings();
/**
* Get the ratings for a particular user. It is guaranteed that no duplicate
* ratings appear - each <i>(user,item)</i> pair is rated at most once.
* @param userId The user's ID.
* @return The user's ratings, or an empty collection if the user is unknown.
*/
FastCollection<IndexedRating> getUserRatings(long userId);
=======
>>>>>>> |
<<<<<<<
Long2ObjectMap<SparseVector> itemRatings =
new Long2ObjectOpenHashMap<SparseVector>(itemData.size());
for (Long2ObjectMap.Entry<Long2DoubleMap> entry: CollectionUtils.fast(itemData.long2ObjectEntrySet())) {
=======
Long2ObjectMap<ItemVector> itemRatings =
new Long2ObjectOpenHashMap<ItemVector>(itemData.size());
ObjectIterator<Long2ObjectMap.Entry<Long2DoubleMap>> iter = itemData.long2ObjectEntrySet().iterator();
while (iter.hasNext()) {
Long2ObjectMap.Entry<Long2DoubleMap> entry = iter.next();
>>>>>>>
Long2ObjectMap<ItemVector> itemRatings =
new Long2ObjectOpenHashMap<ItemVector>(itemData.size());
for (Long2ObjectMap.Entry<Long2DoubleMap> entry: CollectionUtils.fast(itemData.long2ObjectEntrySet())) { |
<<<<<<<
import org.grouplens.lenskit.basic.TopNItemRecommender;
=======
import org.grouplens.lenskit.core.LenskitConfiguration;
>>>>>>>
import org.grouplens.lenskit.basic.TopNItemRecommender;
import org.grouplens.lenskit.core.LenskitConfiguration;
<<<<<<<
LenskitRecommenderEngineFactory factory = new LenskitRecommenderEngineFactory(daof);
factory.bind(ItemScorer.class).to(SlopeOneItemScorer.class);
factory.bind(PreferenceDomain.class).to(new PreferenceDomain(1, 5));
=======
LenskitConfiguration config = new LenskitConfiguration();
config.bind(ItemScorer.class).to(SlopeOneItemScorer.class);
config.bind(ItemRecommender.class).to(SlopeOneRecommender.class);
config.bind(PreferenceDomain.class).to(new PreferenceDomain(1, 5));
>>>>>>>
LenskitConfiguration config = new LenskitConfiguration();
config.bind(ItemScorer.class).to(SlopeOneItemScorer.class);
config.bind(PreferenceDomain.class).to(new PreferenceDomain(1, 5)); |
<<<<<<<
import org.cyclops.integrateddynamics.modcompat.charset.CharsetPipesModCompat;
=======
import org.cyclops.integrateddynamics.modcompat.capabilities.WorkerCoalGeneratorTileCompat;
import org.cyclops.integrateddynamics.modcompat.capabilities.WorkerDryingBasinTileCompat;
import org.cyclops.integrateddynamics.modcompat.capabilities.WorkerSqueezerTileCompat;
import org.cyclops.integrateddynamics.modcompat.jei.JEIModCompat;
>>>>>>>
import org.cyclops.integrateddynamics.modcompat.charset.CharsetPipesModCompat;
import org.cyclops.integrateddynamics.modcompat.capabilities.WorkerCoalGeneratorTileCompat;
import org.cyclops.integrateddynamics.modcompat.capabilities.WorkerDryingBasinTileCompat;
import org.cyclops.integrateddynamics.modcompat.capabilities.WorkerSqueezerTileCompat;
import org.cyclops.integrateddynamics.modcompat.jei.JEIModCompat;
<<<<<<<
modCompatLoader.addModCompat(new CharsetPipesModCompat());
=======
// Mod compats
>>>>>>>
// Mod compats
modCompatLoader.addModCompat(new CharsetPipesModCompat()); |
<<<<<<<
public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(boolean generateId, ItemStack itemStack, IVariableFacadeHandler<F> variableFacadeHandler, IVariableFacadeFactory<F> variableFacadeFactory) {
if(itemStack.isEmpty()) {
return ItemStack.EMPTY;
=======
public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(ItemStack itemStack, F variableFacade, IVariableFacadeHandler<F> variableFacadeHandler) {
if(itemStack == null) {
return null;
}
itemStack = itemStack.copy();
NBTTagCompound tag = ItemStackHelpers.getSafeTagCompound(itemStack);
this.write(tag, variableFacade, variableFacadeHandler);
return itemStack;
}
@Override
public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(boolean generateId, ItemStack itemStack, IVariableFacadeHandler<F> variableFacadeHandler, IVariableFacadeFactory<F> variableFacadeFactory, @Nullable EntityPlayer player, @Nullable Block block) {
if(itemStack == null) {
return null;
>>>>>>>
public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(ItemStack itemStack, F variableFacade, IVariableFacadeHandler<F> variableFacadeHandler) {
if(itemStack.isEmpty()) {
return ItemStack.EMPTY;
}
itemStack = itemStack.copy();
NBTTagCompound tag = ItemStackHelpers.getSafeTagCompound(itemStack);
this.write(tag, variableFacade, variableFacadeHandler);
return itemStack;
}
@Override
public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(boolean generateId, ItemStack itemStack, IVariableFacadeHandler<F> variableFacadeHandler, IVariableFacadeFactory<F> variableFacadeFactory, @Nullable EntityPlayer player, @Nullable Block block) {
if(itemStack.isEmpty()) {
return ItemStack.EMPTY; |
<<<<<<<
=======
import org.cyclops.integrateddynamics.modcompat.ic2.Ic2ModCompat;
import org.cyclops.integrateddynamics.modcompat.immersiveengineering.ImmersiveEngineeringModCompat;
>>>>>>>
<<<<<<<
=======
modCompatLoader.addModCompat(new ImmersiveEngineeringModCompat());
modCompatLoader.addApiCompat(new RfApiCompat());
>>>>>>>
//modCompatLoader.addModCompat(new ImmersiveEngineeringModCompat()); |
<<<<<<<
/**
* Abstract adapter for {@link org.askerov.dynamicgrid.DynamicGridView} with sable items id;
*/
public abstract class AbstractDynamicGridAdapter extends BaseAdapter implements DynamicGridAdapterInterface {
public static final int INVALID_ID = -1;
=======
private int nextStableId = 0;
protected HashMap<Object, Integer> mIdMap = new HashMap<Object, Integer>();
>>>>>>>
/**
* Abstract adapter for {@link org.askerov.dynamicgrid.DynamicGridView} with sable items id;
*/
public abstract class AbstractDynamicGridAdapter extends BaseAdapter implements DynamicGridAdapterInterface {
public static final int INVALID_ID = -1;
private int nextStableId = 0; |
<<<<<<<
=======
import net.minecraft.entity.passive.EntityCow;
import net.minecraft.entity.passive.EntityPig;
import net.minecraft.entity.passive.EntitySheep;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack;
>>>>>>>
import net.minecraft.entity.passive.EntityCow;
import net.minecraft.entity.passive.EntityPig;
import net.minecraft.entity.passive.EntitySheep;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack; |
<<<<<<<
ValueObjectTypeIngredients.ValueIngredients ingredients = variables.getValue(0);
IRecipeHandler recipeHandler = (IRecipeHandler) this.getOperator().getRecipeHandler().orElse(null);
=======
ValueObjectTypeIngredients.ValueIngredients ingredients = variables.getValue(0, ValueTypes.OBJECT_INGREDIENTS);
IRecipeHandler recipeHandler = this.getOperator().getRecipeHandler();
>>>>>>>
ValueObjectTypeIngredients.ValueIngredients ingredients = variables.getValue(0, ValueTypes.OBJECT_INGREDIENTS);
IRecipeHandler recipeHandler = (IRecipeHandler) this.getOperator().getRecipeHandler().orElse(null); |
<<<<<<<
=======
import org.cyclops.integrateddynamics.modcompat.mcmultipart.McMultiPartModCompat;
import org.cyclops.integrateddynamics.modcompat.minetweaker.MineTweakerModCompat;
>>>>>>>
<<<<<<<
//modCompatLoader.addModCompat(new ImmersiveEngineeringModCompat());
=======
modCompatLoader.addModCompat(new ImmersiveEngineeringModCompat());
modCompatLoader.addModCompat(new MineTweakerModCompat());
modCompatLoader.addApiCompat(new RfApiCompat());
>>>>>>>
//modCompatLoader.addModCompat(new ImmersiveEngineeringModCompat());
//modCompatLoader.addModCompat(new MineTweakerModCompat()); |
<<<<<<<
// Doy_Q9012.run();
=======
// Doy_Q9012.run();
>>>>>>>
// Doy_Q9012.run();
<<<<<<<
Hee_Q1991.run();
=======
// Hee_Q10799.run();
// Hee_Q2004.run();
// Hee_Q2086.run();
// Hee_Q10974.run();
// Hee_Q1722.run();
// Hee_Q10845.run();
// Hee_Q10866.run();
// Hee_Q10828.run();
// Hee_Q10808.run();
// Hee_Q10820.run();
// Hee_Q10809.run();
// Hee_Q2743.run();
// Hee_Q11655.run();
// Hee_Q10824.run();
// Hee_Q11656.run();
// Hee_Q3015.run();
// Hee_Q11723.run();
// Hee_Q1927.run();
// Hee_Q7785.run();
// Hee_Q1764.run();
// Hee_Q11279.run();
// Hee_Q1717.run();
// Hee_Q4195.run();
Doy_Q1991.run();
>>>>>>>
// Hee_Q10799.run();
// Hee_Q2004.run();
// Hee_Q2086.run();
// Hee_Q10974.run();
// Hee_Q1722.run();
// Hee_Q10845.run();
// Hee_Q10866.run();
// Hee_Q10828.run();
// Hee_Q10808.run();
// Hee_Q10820.run();
// Hee_Q10809.run();
// Hee_Q2743.run();
// Hee_Q11655.run();
// Hee_Q10824.run();
// Hee_Q11656.run();
// Hee_Q3015.run();
// Hee_Q11723.run();
// Hee_Q1927.run();
// Hee_Q7785.run();
// Hee_Q1764.run();
// Hee_Q11279.run();
// Hee_Q1717.run();
// Hee_Q4195.run();
// Doy_Q1991.run();
Hee_Q1991.run(); |
<<<<<<<
Hee_Q1717.run();
=======
// Doy_Q10799.run();
Hee_Q4195.run();
>>>>>>>
Hee_Q1717.run();
Hee_Q4195.run(); |
<<<<<<<
/*
* Copyright (C) 2012-2019 52°North Initiative for Geospatial Open Source
=======
/**
* Copyright (C) 2012-2020 52°North Initiative for Geospatial Open Source
>>>>>>>
/*
* Copyright (C) 2012-2020 52°North Initiative for Geospatial Open Source |
<<<<<<<
// Hee_Q1707.run();
Hee_Q2331.run();
=======
// Hee_Q11724.run();
// Hee_Q1707.run();
// Hee_Q1922.run();
// Hee_Q1707.run();
// Hee_Q11725.run();
// Hee_Q1167.run();
// Hee_Q1967.run();
// Hee_Q2805.run();
// Hee_Q2110.run();
// Hee_Q1260.run();
Hee_Q10451.run();
// Hee_Q15686.run();
>>>>>>>
// Hee_Q1707.run();
Hee_Q2331.run();
// Hee_Q11724.run();
// Hee_Q1707.run();
// Hee_Q1922.run();
// Hee_Q1707.run();
// Hee_Q11725.run();
// Hee_Q1167.run();
// Hee_Q1967.run();
// Hee_Q2805.run();
// Hee_Q2110.run();
// Hee_Q1260.run();
// Hee_Q10451.run();
// Hee_Q15686.run(); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.