id stringlengths 36 36 | text stringlengths 1 1.25M |
|---|---|
dc114469-538c-43f2-8e18-fa7dfc8fcdf7 | public void setCodigo(String codigo) {
this.codigo = codigo;
} |
c7683b90-21aa-4775-b774-e7abbb64286c | public String getDescricao() {
return descricao;
} |
0c8515f3-d5a2-499a-b07f-1ef74f83c857 | public void setDescricao(String descricao) {
this.descricao = descricao;
} |
68a020db-88b2-4cb1-98a9-f2005e6741ac | public int getQtdEstoq() {
return qtdEstoq;
} |
35bc65a2-44f3-4663-9da3-42f7916e4cdb | public void setQtdEstoq(int qtdEstoq) {
this.qtdEstoq = qtdEstoq;
} |
74ca3801-26fd-406d-8145-1378e9f68bfe | public String getCategoria() {
return categoria;
} |
846dca23-5462-44e1-9be2-a1217363db46 | public void setCategoria(String categoria) {
this.categoria = categoria;
} |
f7db9437-4cb7-4569-b065-048b2a7f9543 | public double getPrecoVenda() {
return precoVenda;
} |
194ea8c7-6ade-4b95-b1ec-ad12ac6cf6cb | public void setPrecoVenda(double precoVenda) {
this.precoVenda = precoVenda;
} |
cbca1252-7253-43dc-bd64-e1d23eb3c4eb | public void cadastroNewEndereco(); |
2f7d1445-0d76-44d8-8675-8482888ac38b | public void editarEndereco(); |
a09ad4b5-5255-4066-b014-aeab2380c00d | public void cadastrarProduto(); |
8309c900-62c4-4287-9146-a49de4513f0a | public void editarProduto(); |
a4a68b87-0cff-4731-b972-8eae3e52be51 | public boolean verificaListaEhVazia(); |
a0a15964-130e-45a9-b531-46422370fa5f | public void cadastrarProduto(ProdutoLivro produto); |
75d575ae-e5ed-41df-859b-e7fbd16ae124 | public void editarProduto(String codigo); |
2dd707b5-2d7b-4ad0-8d1a-e16399cb274d | public boolean buscarProduto(String codigo); |
93d6a5bf-6f3d-4706-b7c6-4a5bd9624f15 | public void listarProdutos(); |
8fe5f7c6-e727-408e-ab88-22fc49c69a26 | public double pegarPreco(String codigoProduto); |
ef239324-494a-4d38-b5ec-5afbfd2e4dff | public void novaCompra(); |
dae986ea-0221-469a-befe-bf69762f44ea | public void listarCompras(); |
12d09e06-4ceb-40f8-9a6e-c59513c39a67 | public boolean verificaListaEhVazia(); |
124634ae-0c99-4297-a974-0da07d814e81 | public int verificaDisponibilidadeEstoque(String codigo); |
91c2dd44-3a2f-4d7d-b7f4-f7c229448dd8 | public void removeProduto(String codigo, int qtdComprada); |
bde81630-63e5-41f3-a76c-7d164e7b0209 | public void alteraStatus(String codVenda); |
33fc04f3-a811-4b70-872f-89bb257798bb | public int escolhaEndereco(int indexComprador); |
48189d9c-b502-4382-b8c4-7143aa3360f8 | public boolean buscarProduto(String codigo); |
552c9b5a-1099-4962-8df1-68c4e11064e8 | public boolean buscaPessoaCPF(String cpf); |
26093a40-e24a-41de-81b9-b44625e5c584 | public int localizarPessoa(String cpf); |
6f79ef1d-3c3e-473c-a9a9-9a2f84a90261 | public double pegarPreco(String codigoProduto); |
83da9446-385c-48b4-9ca9-08b703dc9949 | public boolean buscaPessoa(PessoaTAD pessoa); |
df228678-21d6-48a3-832a-44d6f36c87f5 | public boolean verificaListaEhVazia(); |
a371a5aa-8bc2-4ee4-9bac-578e7126d1f8 | public boolean buscaPessoaCPF(String cpf); |
38e6f4d3-f9d8-414e-83e7-77a282fd10fd | public int localizarPessoa(String cpf); |
5b4f4c45-f486-4dd5-a5ee-c9d4e5ce89f8 | public void cadastraPessoa(PessoaTAD pessoa); |
c8ea5889-dacf-4c38-97a5-1e46c33f3813 | public void cadastrarMaisEndereco(String cpf); |
db1bac93-c17c-40af-bd69-a757c1e4e3da | public void editarPessoa(String CPF); |
27b97080-46c2-40a7-82ef-8f7530a73344 | public void listarPessoa(); |
e8222d75-b0e1-4aa9-b2ea-835c4d568aa8 | public static int count( String procedureName, String event ){
return stats.add(procedureName + event, 1);
} |
db04ff7a-3160-4ad8-bbad-9bbed550af5e | public static int getCount( String procedureName, String event ){
return stats.count(procedureName + event);
} |
3f8413b7-982a-4f7d-85ca-838396c6f6ea | public static void printProcedureResults(String procedureName) {
System.out.println(" " + procedureName);
System.out.println(" calls: " + getCount(procedureName,"call"));
System.out.println(" commits: " + getCount(procedureName,"commit"));
System.out.println(" rollbacks: " + getCount(procedureName,"rollback"));
} |
eeeb9bd2-453b-4d87-b8d6-276ea0b40fe5 | public BenchmarkCallback(String procedure, long maxErrors) {
super();
this.procedureName = procedure;
this.maxErrors = maxErrors;
} |
e8a3ddf5-c3a8-4cfd-8172-e0c71a4b1e1c | public BenchmarkCallback(String procedure) {
this(procedure, 5l);
} |
8d5d2b75-b596-4c81-a09b-5aa83fe46e82 | @Override
public void clientCallback(ClientResponse cr) {
count(procedureName,"call");
if (cr.getStatus() == ClientResponse.SUCCESS) {
count(procedureName,"commit");
} else {
long totalErrors = count(procedureName,"rollback");
if (totalErrors > maxErrors) {
System.err.println("exceeded " + maxErrors + " maximum database errors - exiting client");
System.exit(-1);
}
System.err.println("DATABASE ERROR: " + cr.getStatusString());
}
} |
62445419-c7c5-4dbb-830c-ebd82c2d24e8 | public BenchmarkConfig() {
} |
da348824-7b38-46fb-9c8e-24510883f607 | public static BenchmarkConfig getConfig(String classname, String[] args) {
BenchmarkConfig config = new BenchmarkConfig();
config.parse(classname, args);
return config;
} |
d2c2c2b9-0249-4e83-a7f0-2065dfe064c2 | @Override
public void validate() {
if (duration <= 0) exitWithMessageAndUsage("duration must be > 0");
if (warmup < 0) exitWithMessageAndUsage("warmup must be >= 0");
if (displayinterval <= 0) exitWithMessageAndUsage("displayinterval must be > 0");
if (ratelimit <= 0) exitWithMessageAndUsage("ratelimit must be > 0");
if (latencytarget <= 0) exitWithMessageAndUsage("latencytarget must be > 0");
} |
259f77f5-e68c-44ce-8737-b5ee03b2ddf5 | public long run( int codord,
int ord_cnt,
int ord_sec,
int ord_qty,
double ord_prc
) throws VoltAbortException {
voltQueueSQL(insertOrder,
codord,
ord_cnt,
ord_sec,
ord_qty,
ord_prc);
voltQueueSQL(updatePos,
ord_qty,
ord_sec,
ord_cnt);
VoltTable results1[] = voltExecuteSQL();
long rowsAffected = results1[1].asScalarLong();
if (rowsAffected == 0) {
// then insert
voltQueueSQL(insertPos,
ord_cnt,
ord_sec,
ord_qty,
0,
ord_prc,
ord_qty * ord_prc,
0);
voltExecuteSQL();
}
return ClientResponse.SUCCESS;
} |
c663621b-c8bc-46fa-85f8-3f72ba732b5a | public long run( int codtrd,
int trd_cnt,
int trd_sec,
int trd_qty,
double trd_prc
) throws VoltAbortException {
voltQueueSQL(insertTrade,
codtrd,
trd_cnt,
trd_sec,
trd_qty,
trd_prc);
voltQueueSQL(updatePos,
trd_qty,
trd_sec,
trd_cnt);
VoltTable results1[] = voltExecuteSQL();
long rowsAffected = results1[1].asScalarLong();
if (rowsAffected == 0) {
// then insert
voltQueueSQL(insertPos,
trd_cnt,
trd_sec,
0,
trd_qty,
trd_prc,
0,
trd_qty * trd_prc
);
voltExecuteSQL();
}
return ClientResponse.SUCCESS;
} |
2ee02245-56be-4a0c-9b05-02b537154049 | public VoltTable[] run( int codprc,
int prc_sec,
double prc_price,
Date prc_ts
) throws VoltAbortException {
voltQueueSQL(insertPrice,
codprc,
prc_sec,
prc_price,
prc_ts);
voltQueueSQL(updatePos,
prc_price,
prc_price,
prc_price,
prc_sec);
return voltExecuteSQL();
} |
a7d4f474-4b12-4620-a2db-960bba1714ef | public void loadInitialModelState(int size, int playerCount) {
gridSize = size;
waitingState = 0;
currentTurn = 1;
this.playerCount = playerCount;
// Clock instantiation
percent = -1;
turnLength = 10 * 1000;
turnTimer = new Timer(0, new ActionListener() {
@Override
public void actionPerformed(ActionEvent evt) {
if (percent == 9) {
turnTimer.setRepeats(false);
}
if (percent == 10) {
percent = -1;
rotateTurn();
}
percent++;
}
});
turnTimer.setDelay(turnLength / 10);
turnTimer.setRepeats(true);
turnTimer.start();
// Creates 2d arrays for terrain, units, and model.
// Initializes them.
terrainP1 = new Terrain[size][size];
generateMap(terrainP1);
unitsP1 = new AbstractUnit[size][size];
int c = (int) (Math.random() * size / 4);
int r = (int) (Math.random() * size / 4);
unitsP1[c][r] = new PhysicalBuilder(1, size * c + r);
unitsP1[c][r].setVisible(true);
unitsP1[c][r].setActive(true);
visualModelP1 = new int[size][size * 2];
generateVisualModel(visualModelP1, unitsP1, terrainP1);
terrainP2 = new Terrain[size][size];
copyMap(terrainP1, terrainP2);
unitsP2 = new AbstractUnit[size][size];
c = (int) (Math.random() * size / 4 + size * 3 / 4);
r = (int) (Math.random() * size / 4 + size * 3 / 4);
unitsP2[c][r] = new PhysicalBuilder(2, size * c + r);
unitsP2[c][r].setVisible(true);
unitsP2[c][r].setActive(true);
visualModelP2 = new int[size][size * 2];
generateVisualModel(visualModelP2, unitsP2, terrainP2);
if (playerCount > 2) {
terrainP3 = new Terrain[size][size];
copyMap(terrainP1, terrainP3);
unitsP3 = new AbstractUnit[size][size];
c = (int) (Math.random() * size / 4);
r = (int) (Math.random() * size / 4 + size * 3 / 4);
unitsP3[c][r] = new PhysicalBuilder(3, size * c + r);
unitsP3[c][r].setVisible(true);
unitsP3[c][r].setActive(true);
visualModelP3 = new int[size][size * 2];
generateVisualModel(visualModelP3, unitsP3, terrainP3);
}
if (playerCount > 3) {
terrainP4 = new Terrain[size][size];
copyMap(terrainP1, terrainP4);
unitsP4 = new AbstractUnit[size][size];
c = (int) (Math.random() * size / 4 + size * 3 / 4);
r = (int) (Math.random() * size / 4);
unitsP4[c][r] = new PhysicalBuilder(4, size * c + r);
unitsP4[c][r].setVisible(true);
unitsP4[c][r].setActive(true);
visualModelP4 = new int[size][size * 2];
generateVisualModel(visualModelP4, unitsP4, terrainP4);
}
} |
14cd3c45-e479-4285-ad9a-ae959119de61 | @Override
public void actionPerformed(ActionEvent evt) {
if (percent == 9) {
turnTimer.setRepeats(false);
}
if (percent == 10) {
percent = -1;
rotateTurn();
}
percent++;
} |
09f43b8c-cc2c-43ae-9d91-1d8bdaa2277c | private void generateVisualModel(int[][] visM, AbstractUnit[][] units, Terrain[][] terrain) {
for (int r = 0; r < units.length; r++) {
for (int c = 0; c < units.length; c++) {
visM[r][c] = units[r][c] != null ? units[r][c].toInt() : -1;
visM[r][c + units.length] = terrain[r][c].getPictureID();
}
}
} |
af4f48ae-3c50-41bc-a009-321b74c51d63 | private void copyMap(Terrain[][] origin, Terrain[][] dest) {
for (int r = 0; r < origin.length; r++) {
for (int c = 0; c < origin.length; c++) {
dest[r][c] = origin[r][c];
}
}
} |
f9eb0e20-2acc-43da-bec9-98a5fd0e02aa | private void generateMap(Terrain[][] dest) {
// Divide the map into 10-20% width and length seed zones.
int zonePercent = ((int) (11 * Math.random())) + 10, zoneLength = gridSize / zonePercent;
int seedType;
for (int x = 0; x < zonePercent; x++) {
for (int y = 0; y < zonePercent; y++) {
int seedC = zoneLength * x + zoneLength / 2;
int seedR = zoneLength * y + zoneLength / 2;
seedType = (int) (5 * Math.random());
dest[seedR][seedC] = new Terrain(seedType, seedType * 9 + ((int) (9 * Math.random())));
for (int i = 1; i <= zoneLength / 2; i++) {
double chanceTarget = (double) i / (zoneLength / 2) - (double) 1 / (zoneLength / 2);
for (int c = seedC - i; c <= seedC + i; c++) {
if (Math.random() >= chanceTarget && seedR - i > -1 && c > -1 && c < gridSize)
dest[seedR - i][c] = new Terrain(seedType, seedType * 9 + ((int) (9 * Math.random())));
if (Math.random() >= chanceTarget && seedR + i < gridSize && c > -1 && c < gridSize)
dest[seedR + i][c] = new Terrain(seedType, seedType * 9 + ((int) (9 * Math.random())));
}
for (int r = seedR - i + 1; r <= seedR + i - 1; r++) {
if (Math.random() >= chanceTarget && seedC - i > -1 && r > -1 && r < gridSize)
dest[r][seedC - i] = new Terrain(seedType, seedType * 9 + ((int) (9 * Math.random())));
if (Math.random() >= chanceTarget && seedC + i < gridSize && r > -1 && r < gridSize)
dest[r][seedC + i] = new Terrain(seedType, seedType * 9 + ((int) (9 * Math.random())));
}
}
}
}
for (int r = 0; r < gridSize; r++) {
for (int c = 0; c < gridSize; c++) {
if (dest[r][c] == null) {
seedType = (int) (5 * Math.random());
dest[r][c] = new Terrain(seedType, seedType * 9 + ((int) (9 * Math.random())));
}
}
}
} |
3a5deaae-ffb9-4bec-b077-c1643873d5b8 | protected void rotateTurn() {
if (currentTurn < playerCount) {
currentTurn += 1;
PrimaryController.generateNotification("Switching to Player " + currentTurn, 0);
turnTimer.setRepeats(true);
percent = 0;
turnTimer.start();
}
else {
for (int r = 0; r < unitsP1.length; r++) {
for (int c = 0; c < unitsP1.length; c++) {
if (unitsP1[r][c].toInt() != 0) {
activityQueue.add(unitsP1[r][c].getActivityList());
}
if (unitsP2[r][c].toInt() != 0) {
activityQueue.add(unitsP2[r][c].getActivityList());
}
if (unitsP3[r][c].toInt() != 0) {
activityQueue.add(unitsP3[r][c].getActivityList());
}
if (unitsP4[r][c].toInt() != 0) {
activityQueue.add(unitsP4[r][c].getActivityList());
}
}
}
activityQueue.process();
// Consider how to implement the chain of activities
currentTurn = 1;
}
waitingState = 1;
} |
ceda462e-ac5d-4421-bece-eb45d4839fae | public int[][] getVisualModel() {
switch (currentTurn) {
case 1:
return visualModelP1;
case 2:
return visualModelP2;
case 3:
return visualModelP3;
default:
return visualModelP4;
}
} |
2d1be75f-08d8-4a25-8a5f-e39d316f6d12 | public int getClockFace() {
return percent;
} |
ca8b8c3a-a3e1-4ad9-9d09-f045fc6a6d98 | public void transferUnit(int srcR, int srcC, int destR, int destC) {
AbstractUnit temp;
switch (currentTurn) {
case 1:
temp = unitsP1[srcR][srcC];
unitsP1[srcR][srcC] = unitsP1[destR][destC];
unitsP1[destR][destC] = temp;
visualModelP1[srcR][srcC] = -1;
visualModelP1[destR][destC] = unitsP1[destR][destC].toInt();
break;
case 2:
temp = unitsP2[srcR][srcC];
unitsP2[srcR][srcC] = unitsP2[destR][destC];
unitsP2[destR][destC] = temp;
visualModelP2[srcR][srcC] = -1;
visualModelP2[destR][destC] = unitsP2[destR][destC].toInt();
break;
case 3:
temp = unitsP3[srcR][srcC];
unitsP3[srcR][srcC] = unitsP3[destR][destC];
unitsP3[destR][destC] = temp;
visualModelP3[srcR][srcC] = -1;
visualModelP3[destR][destC] = unitsP3[destR][destC].toInt();
break;
default:
temp = unitsP4[srcR][srcC];
unitsP4[srcR][srcC] = unitsP4[destR][destC];
unitsP4[destR][destC] = temp;
visualModelP4[srcR][srcC] = -1;
visualModelP4[destR][destC] = unitsP4[destR][destC].toInt();
break;
}
} |
661db7c0-4023-4679-9094-1a9b59ccfdf6 | public String getDescriptor(int r, int c) {
switch (currentTurn) {
case 1:
if (c < unitsP1.length )
return unitsP1[r][c].getDescriptor();
else
return terrainP1[r][c - unitsP1.length].getDescriptor();
case 2:
if (c < unitsP2.length )
return unitsP2[r][c].getDescriptor();
else
return terrainP2[r][c - unitsP2.length].getDescriptor();
case 3:
if (c < unitsP3.length )
return unitsP3[r][c].getDescriptor();
else
return terrainP3[r][c - unitsP3.length].getDescriptor();
default:
if (c < unitsP4.length )
return unitsP4[r][c].getDescriptor();
else
return terrainP4[r][c - unitsP4.length].getDescriptor();
}
} |
f3a2ff9e-350c-430a-9fa8-5cc5484d85e9 | public void loadInitialViewState(GraphicsConfiguration gC, int units) {
this.gC = gC;
screenWidth = gC.getBounds().width;
screenHeight = gC.getBounds().height;
visX = 0;
visY = 0;
if (screenWidth >= 2560 && screenHeight >= 1440) {
xOffset = (screenWidth - 2560) / 2;
yOffset = (screenHeight - 1440) / 2;
iPaneWidth = 2560;
iPaneHeight = 140;
unitLength = 52;
clockLength = 132;
clockOffset = 4;
portraitWidth = 170;
portraitHeight = 208;
endTurnX = xOffset + 12;
endTurnY = screenHeight - yOffset - iPaneHeight + 196;
endTurnWidth = 174;
endTurnHeight = 80;
resKey = 0;
} else if (screenWidth >= 1920 && screenHeight >= 1080) {
xOffset = (screenWidth - 1920) / 2;
yOffset = (screenHeight - 1080) / 2;
iPaneWidth = 1920;
iPaneHeight = 105;
unitLength = 39;
clockLength = 99;
clockOffset = 3;
portraitWidth = 128;
portraitHeight = 156;
endTurnX = xOffset + 9;
endTurnY = screenHeight - yOffset - iPaneHeight + 147;
endTurnWidth = 130;
endTurnHeight = 60;
resKey = 1;
} else if (screenWidth >= 1600 && screenHeight >= 900) {
xOffset = (screenWidth - 1600) / 2;
yOffset = (screenHeight - 900) / 2;
iPaneWidth = 1600;
iPaneHeight = 75;
unitLength = 33;
clockLength = 105;
clockOffset = 9;
portraitWidth = 105;
portraitHeight = 130;
endTurnX = xOffset + 8;
endTurnY = screenHeight - yOffset - iPaneHeight + 123;
endTurnWidth = 108;
endTurnHeight = 49;
resKey = 2;
} else if (screenWidth >= 1280 && screenHeight >= 720) {
xOffset = (screenWidth - 1280) / 2;
yOffset = (screenHeight - 720) / 2;
iPaneWidth = 1280;
iPaneHeight = 70;
unitLength = 26;
clockLength = 85;
clockOffset = 7;
portraitWidth = 85;
portraitHeight = 105;
endTurnX = xOffset + 6;
endTurnY = screenHeight - yOffset - iPaneHeight + 98;
endTurnWidth = 87;
endTurnHeight = 40;
resKey = 3;
} else {
System.exit(0);
}
pixelLength = unitLength * units;
boundX = this.pixelLength - screenWidth;
boundY = this.pixelLength - screenHeight + iPaneHeight;
terrainImages = new VolatileImage[90];
for (int i = 0; i < terrainImages.length; i++) {
terrainImages[i] = gC.createCompatibleVolatileImage(unitLength, unitLength);
}
unitImages = new VolatileImage[40];
for (int i = 0; i < unitImages.length; i++) {
unitImages[i] = gC.createCompatibleVolatileImage(unitLength, unitLength, VolatileImage.TRANSLUCENT);
}
unitFocusImages = new VolatileImage[40];
for (int i = 0; i < unitFocusImages.length; i++) {
unitFocusImages[i] = gC.createCompatibleVolatileImage(unitLength * 3, unitLength * 3);
}
informationPanel = gC.createCompatibleVolatileImage(iPaneWidth, iPaneHeight);
clockImage = gC.createCompatibleVolatileImage(clockLength, clockLength, VolatileImage.TRANSLUCENT);
portrait = gC.createCompatibleVolatileImage(portraitWidth, portraitHeight, VolatileImage.TRANSLUCENT);
} |
063176f6-9496-4180-83ba-5581b6fbc16d | public void render(Graphics g, int[][] gameState) {
// Calculate drawn squares
int cStart = visX / unitLength + gameState.length;
int rStart = visY / unitLength;
int cEnd = cStart + (screenWidth - 2 * xOffset) / unitLength + 1;
int rEnd = rStart + (screenHeight - 2 * yOffset) / unitLength + 1;
// Traversing the 2D gameState array to draw
// terrain tiles. The do while ensures the images
// actually get drawn. Applies for the populate units
// region as well.
for (int r = rStart; r < rEnd && r < gameState.length; r++) {
for (int c = cStart; c < cEnd && c < gameState.length * 2; c++) {
int i = gameState[r][c];
do {
int valCode = terrainImages[i].validate(gC);
if (valCode == VolatileImage.IMAGE_RESTORED) {
restoreTerrainTile(i);
} else if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
terrainImages[i] = gC.createCompatibleVolatileImage(unitLength, unitLength);
} else if (valCode == VolatileImage.IMAGE_OK) {
g.drawImage(terrainImages[i], ((c - gameState.length) * unitLength) - visX + xOffset,
(r * unitLength) - visY + yOffset, null);
}
} while (terrainImages[i].contentsLost());
}
}
// Populate Units
for (int r = rStart; r < rEnd && r < gameState.length; r++) {
for (int c = cStart - gameState.length; c < cEnd - gameState.length && c < gameState.length * 2; c++) {
int i = gameState[r][c];
if (i > -1) {
do {
int valCode = unitImages[i].validate(gC);
if (valCode == VolatileImage.IMAGE_RESTORED) {
restoreUnitTile(i);
} else if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
unitImages[i] = gC.createCompatibleVolatileImage(unitLength, unitLength, VolatileImage.TRANSLUCENT);
} else if (valCode == VolatileImage.IMAGE_OK) {
g.drawImage(unitImages[i], (c * unitLength) - visX + xOffset,
(r * unitLength) - visY + yOffset, null);
}
} while (unitImages[i].contentsLost());
}
}
}
// Draw the highlight boxes for displaying the unit's movement radius.
if (focusingUnit) {
focusBoxX = focusC * unitLength - unitLength - visX;
focusBoxY = focusR * unitLength - unitLength - visY;
if (focusC * unitLength < visX + unitLength) {
focusBoxX = xOffset;
}
if (focusC * unitLength > visX + screenWidth - xOffset - unitLength * 2) {
focusBoxX = screenWidth - 2 * xOffset - unitLength * 3;
}
if (focusR * unitLength < visY + unitLength) {
focusBoxY = yOffset;
}
if (focusR * unitLength > visY + screenHeight - yOffset - iPaneHeight - unitLength * 2) {
focusBoxY = screenWidth - 2 * yOffset - unitLength * 3;
}
do {
int valCode = unitFocusImages[0].validate(gC);
if (valCode == VolatileImage.IMAGE_RESTORED) {
restoreUnitFocusImage(0);
} else if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
unitFocusImages[0] = gC.createCompatibleVolatileImage(unitLength, unitLength);
} else if (valCode == VolatileImage.IMAGE_OK) {
g.drawImage(unitFocusImages[0], focusBoxX,
focusBoxY, null);
}
} while (unitFocusImages[0].contentsLost());
g.setColor(Color.GREEN);
int stroke = unitLength * 5 / 100;
for (int r = focusR - focusRad; r < focusR + focusRad + 1; r++)
for (int c = focusC - focusRad; c < focusC + focusRad + 1; c++) {
// Upper Stroke
g.fillRect(c * unitLength - visX + xOffset - stroke, r * unitLength - visY + yOffset - stroke, unitLength + stroke * 2, stroke);
// Left Stroke
g.fillRect(c * unitLength - visX + xOffset - stroke, r * unitLength - visY + yOffset - stroke, stroke, unitLength + stroke * 2);
// Bottom Stroke
g.fillRect(c * unitLength - visX + xOffset - stroke, r * unitLength - visY + yOffset + unitLength, unitLength + stroke * 2, stroke);
// Right Stroke
g.fillRect(c * unitLength - visX + xOffset + unitLength, r * unitLength - visY + yOffset - stroke, stroke, unitLength + stroke * 2);
}
}
// Information Panel
do {
int valCode = informationPanel.validate(gC);
if (valCode == VolatileImage.IMAGE_RESTORED) {
restoreInformationPanel();
} else if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
informationPanel = gC.createCompatibleVolatileImage(iPaneWidth, iPaneHeight);
} else if (valCode == VolatileImage.IMAGE_OK) {
g.drawImage(informationPanel, xOffset, screenHeight - yOffset - iPaneHeight, null);
}
} while (informationPanel.contentsLost());
// Clock Face
do {
restoreClockImage();
int valCode = clockImage.validate(gC);
if (valCode == VolatileImage.IMAGE_RESTORED) {
restoreClockImage();
} else if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
clockImage = gC.createCompatibleVolatileImage(clockLength, clockLength, VolatileImage.TRANSLUCENT);
} else if (valCode == VolatileImage.IMAGE_OK) {
g.drawImage(clockImage, xOffset + clockOffset, screenHeight - yOffset - iPaneHeight + clockOffset, null);
}
} while (clockImage.contentsLost());
// if (focusing) {
// int i = gameState[focusR][focusC];
//
// do {
// int valCode = unitImages[i].validate(gC);
//
// if (valCode == VolatileImage.IMAGE_RESTORED) {
// restoreUnitTile(i);
// } else if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
// unitImages[i] = gC.createCompatibleVolatileImage(unitLength, unitLength, VolatileImage.TRANSLUCENT);
// } else if (valCode == VolatileImage.IMAGE_OK) {
// g.drawImage(unitImages[i], 170, 886, null);
// g.setColor(Color.WHITE);
// g.drawString(focusName, 1162, 1061);
// }
// } while (unitImages[i].contentsLost());
//
// do {
// int valCode = portrait.validate(gC);
//
// if (valCode == VolatileImage.IMAGE_RESTORED) {
// restorePortrait();
// } else if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
// portrait = gC.createCompatibleVolatileImage(128, 157, VolatileImage.TRANSLUCENT);
// } else if (valCode == VolatileImage.IMAGE_OK) {
// g.drawImage(portrait, 1148, 874, null);
// }
// } while (portrait.contentsLost());
// }
// Draw black rectangles in xOffset and yOffset regions
g.setColor(Color.BLACK);
g.fillRect(0, 0, xOffset, screenHeight);
g.fillRect(0, 0, screenWidth, yOffset);
g.fillRect(screenWidth - xOffset, 0, xOffset, screenHeight);
g.fillRect(0, screenHeight - yOffset, screenWidth, screenHeight);
} |
7c45d88a-7712-4aac-9ec0-2a10b742b8b8 | private void restorePortrait() {
Graphics2D g = null;
do {
if (portrait.validate(gC) == VolatileImage.IMAGE_INCOMPATIBLE) {
portrait = gC.createCompatibleVolatileImage(portraitWidth, portraitHeight, VolatileImage.TRANSLUCENT);
}
try {
g = portrait.createGraphics();
g.setComposite(AlphaComposite.Src);
g.drawImage((new ImageIcon(getClass().getClassLoader()
.getResource("images/Portraits/" + resKey + "/P_0.jpg"))).getImage(), 0,
0, null);
} finally {
g.dispose();
}
} while (portrait.contentsLost());
} |
16dd795f-936b-4c73-af6d-488fe08c4890 | private void restoreClockImage() {
Graphics2D g = null;
do {
if (clockImage.validate(gC) == VolatileImage.IMAGE_INCOMPATIBLE) {
clockImage = gC.createCompatibleVolatileImage(clockLength, clockLength, VolatileImage.TRANSLUCENT);
}
try {
g = clockImage.createGraphics();
g.setComposite(AlphaComposite.Src);
g.drawImage((new ImageIcon(getClass().getClassLoader()
.getResource("images/Clock/" + resKey + "/C_" + clockFace + ".png"))).getImage(), 0,
0, null);
} finally {
g.dispose();
}
} while (clockImage.contentsLost());
} |
afeec579-4488-457c-abc0-d6366d6b7395 | private void restoreUnitTile(int i) {
Graphics2D g = null;
do {
if (unitImages[0].validate(gC) == VolatileImage.IMAGE_INCOMPATIBLE) {
unitImages[0] = gC.createCompatibleVolatileImage(unitLength, unitLength, VolatileImage.TRANSLUCENT);
}
try {
g = unitImages[0].createGraphics();
g.setComposite(AlphaComposite.Src);
g.drawImage((new ImageIcon(getClass().getClassLoader()
.getResource("images/Units/" + resKey + "/Tile/" + 0 + "/U_" + i + ".png"))).getImage(), 0,
0, null);
} finally {
g.dispose();
}
} while (unitImages[0].contentsLost());
} |
6d3ac120-959e-4c52-b73b-4b9156687957 | private void restoreUnitFocusImage(int i) {
Graphics2D g = null;
do {
if (unitFocusImages[0].validate(gC) == VolatileImage.IMAGE_INCOMPATIBLE) {
unitFocusImages[0] = gC.createCompatibleVolatileImage(unitLength * 3, unitLength * 3);
}
try {
g = unitFocusImages[0].createGraphics();
g.drawImage((new ImageIcon(getClass().getClassLoader()
.getResource("images/Units/" + resKey + "/Focus/" + 0 + "/U_" + i + "_F.jpg"))).getImage(), 0,
0, null);
} finally {
g.dispose();
}
} while (unitImages[0].contentsLost());
} |
97d8704d-2c4f-4dfd-83e2-c8b6f2132c1e | private void restoreInformationPanel() {
Graphics2D g = null;
do {
if (informationPanel.validate(gC) == VolatileImage.IMAGE_INCOMPATIBLE) {
informationPanel = gC.createCompatibleVolatileImage(iPaneWidth, iPaneHeight);
}
try {
g = informationPanel.createGraphics();
g.drawImage((new ImageIcon(getClass().getClassLoader()
.getResource("images/Information Panel/" + resKey + "/I_0.jpg"))).getImage(), 0,
0, null);
} finally {
g.dispose();
}
} while (informationPanel.contentsLost());
} |
7a646d49-aed2-4a67-88da-0a8b5de72552 | private void restoreTerrainTile(int i) {
Graphics2D g = null;
do {
if (terrainImages[i].validate(gC) == VolatileImage.IMAGE_INCOMPATIBLE) {
terrainImages[i] = gC.createCompatibleVolatileImage(unitLength, unitLength);
}
try {
g = terrainImages[i].createGraphics();
g.drawImage((new ImageIcon(getClass().getClassLoader()
.getResource("images/Terrain/" + resKey + "/Tile/T_" + i + ".jpg"))).getImage(), 0,
0, null);
} finally {
g.dispose();
}
} while (terrainImages[i].contentsLost());
} |
0bcd2596-7748-4ae4-b080-6c51f2be8370 | public void scrollWest() {
if (visX > 9) {
visX -= 10;
}
} |
719ea3fc-468c-4064-9942-9f510e3143f6 | public void scrollNorthWest() {
if (visY > 9) {
visY -= 10;
}
if (visX > 9) {
visX -= 10;
}
} |
30a87fdd-0ed2-44f7-a9b3-c2f7cf2392fd | public void scrollNorth() {
if (visY > 9) {
visY -= 10;
}
} |
8172ab86-fe34-44f5-aed9-2b0bef23ed29 | public void scrollNorthEast() {
if (visY > 9) {
visY -= 10;
}
if (visX < boundX - 9) {
visX += 10;
}
} |
ef5e0d84-a71f-4e05-8eb0-da596bda5250 | public void scrollEast() {
if (visX < boundX - 9) {
visX += 10;
}
} |
8a076330-79be-4914-8379-8c38b09fab5a | public void scrollSouthEast() {
if (visY < boundY - 9) {
visY += 10;
}
if (visX < boundX - 9) {
visX += 10;
}
} |
cc3a4bf5-e83a-4b63-aaa5-44e206780256 | public void scrollSouth() {
if (visY < boundY - 9) {
visY += 10;
}
} |
d3c5b639-4ede-4c37-9dad-f2f5e3bc9436 | public void scrollSouthWest() {
if (visY < boundY - 9) {
visY += 10;
}
if (visX > 9) {
visX -= 10;
}
} |
528f3a72-d4ac-4b1a-b009-159e88ca5342 | public int getVisX() {
return visX;
} |
03957f80-2f8f-444b-bff8-e0eeaf1b0d66 | public int getVisY() {
return visY;
} |
e380e8ef-80f7-48f2-afa4-29bc4ca24369 | public void setFocusTarget(int r, int c, int rad, String descriptor) {
focusingUnit = true;
focusR = r;
focusC = c;
focusRad = rad;
focusDescriptor = descriptor;
} |
3aafa13f-c163-44f9-a9c2-04436768118f | public void setTerrainFocusTarget(int c, int r, String descriptor) {
focusC = c;
focusR = r;
focusDescriptor = descriptor;
focusingTerrain = true;
} |
d91e5cab-5ab5-4eec-b0cd-c36ac95bf84f | public void updateClock(int face) {
clockFace = face;
} |
c63b5f44-1129-4569-9301-e30f6bf32f86 | public Point getFocusTarget() {
return new Point(focusR, focusC);
} |
f7c464e9-3878-410c-84b3-946d69cdc2a9 | public int getIPaneHeight() {
return iPaneHeight;
} |
a03fa6e2-3cfb-42f7-81c0-fcb773fcd8e9 | public int getXOffset() {
return xOffset;
} |
923cbffb-e04f-44e1-9a63-9b89661713ce | public int getYOffset() {
return yOffset;
} |
658420f2-2f51-4f80-a108-7b8589c180a4 | public int getUnitLength() {
return unitLength;
} |
ff1eb314-c862-4a24-8ae7-af19336a19b7 | public int getEndTurnX() {
return endTurnX;
} |
7a8f7a3a-ab27-4312-86be-bc2dc19d735b | public int getEndTurnY() {
return endTurnY;
} |
67673378-c525-42b8-ac19-f61db53f878a | public int getEndTurnWidth() {
return endTurnWidth;
} |
6ec8d5d0-755f-4a09-8d3c-6f668df510bc | public int getEndTurnHeight() {
return endTurnHeight;
} |
ce7b1e09-a29e-45e3-9b4f-3a838a7d960f | public void clearFocusTarget() {
focusingUnit = false;
} |
f3e99ec9-373e-4c74-bb11-dd3a4c6269dd | public Point getFocusBoxCoords() {
return new Point(focusBoxX, focusBoxY);
} |
fb1a0fdc-f6d2-49d2-a50e-ae0451412bf9 | public void organize() {
if(size() < 2)
return;
for(int i = 0; i < size() - 1; i++) {
for (int j = i + 1; j < size(); j++) {
if (!get(i).comparePriority(get(j))); {
Collections.swap(this, i, j);
}
}
}
} |
90468454-17d3-4052-afb1-36116ceb2810 | public static void main(String args[]) {
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
PrimaryController p = new PrimaryController();
p.loadInitialGameState();
p.startGame();
}
});
} |
9045c3ab-241f-4e80-8c62-d47722997bc2 | public void run() {
PrimaryController p = new PrimaryController();
p.loadInitialGameState();
p.startGame();
} |
abf09fa1-cc8f-43bf-b236-2ff983b2ffee | public Activity (int aP, int rP, int aT, int pI, int aD, int aR) {
activityKeys[0] = aP;
activityKeys[1] = rP;
activityKeys[2] = aT;
activityKeys[3] = pI;
activityKeys[4] = aD;
activityKeys[5] = aR;
} |
4343c5e0-158f-46a9-ad2d-43444edfccc0 | public int[] provideActivityKeys() {
return activityKeys;
} |
588a9469-1a69-46b2-a80f-72e2c1e13468 | public boolean comparePriority(Activity otherAct) {
// TODO Implement a reasonable comparison for two activities.
// Keep in mind key-frame divisions as well as order of entry
// into the queue. Perhaps add some keys for those ideas.
// If the otherAct should occur after thisAct, then return true.
return false;
} |
ec74005d-343f-4fe0-ad08-5b1a4f2f34dc | public Terrain(int id, int picID) {
type = id;
pictureID = picID;
} |
03c84273-6de0-41b8-85fd-d29a2f30ab10 | public int getPictureID() {
return pictureID;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.