From 1ad27dca66d845c1dfb606410b81b7437ee51b75 Mon Sep 17 00:00:00 2001 From: Mysaa Date: Sun, 23 May 2021 20:41:37 +0200 Subject: [PATCH] =?UTF-8?q?Premier=20commit=20-=20Inclusion=20dans=20le=20?= =?UTF-8?q?syst=C3=A8me=20git.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 5 + src/com/bernard/bataille/Card.java | 87 +++++++ src/com/bernard/bataille/CardType.java | 5 + src/com/bernard/bataille/Component.java | 67 ++++++ src/com/bernard/bataille/Componentizer.java | 224 +++++++++++++++++++ src/com/bernard/bataille/CrapoyamsMotor.java | 137 ++++++++++++ src/com/bernard/bataille/GameManager.java | 159 +++++++++++++ src/com/bernard/bataille/Renderable.java | 7 + 8 files changed, 691 insertions(+) create mode 100644 .gitignore create mode 100644 src/com/bernard/bataille/Card.java create mode 100644 src/com/bernard/bataille/CardType.java create mode 100644 src/com/bernard/bataille/Component.java create mode 100644 src/com/bernard/bataille/Componentizer.java create mode 100644 src/com/bernard/bataille/CrapoyamsMotor.java create mode 100644 src/com/bernard/bataille/GameManager.java create mode 100644 src/com/bernard/bataille/Renderable.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..80e6836 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.classpath +.project +.settings/ +bin/ + diff --git a/src/com/bernard/bataille/Card.java b/src/com/bernard/bataille/Card.java new file mode 100644 index 0000000..38cbf3e --- /dev/null +++ b/src/com/bernard/bataille/Card.java @@ -0,0 +1,87 @@ +package com.bernard.bataille; + +import static java.lang.Math.*; + +import java.awt.Graphics2D; +import java.awt.Image; +import java.awt.geom.AffineTransform; +import java.io.File; +import java.io.IOException; + +import javax.imageio.ImageIO; + +public class Card { + + int type;// couleur*13 + genre + //12->as,11->roi,10->dame,...,0->2 + //♠->0,♣->1,♥->2,♦->3 + Pos pos; + public static File backCardImage = new File("/home/mysaa/Pictures/cardBackL.png"); + public static File tempCardsPNGFolder = new File("/tmp/cardsPNG/"); + + + + public Card(int type, Pos pos) { + this.type = type; + this.pos = pos; + } + + + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return "Card [type=" + type + ", pos=" + pos + "]"; + } + + + + public void draw(Graphics2D g,int wc, int hc) { + try { + AffineTransform t = g.getTransform(); + System.out.println(pos); + Image img = ((pos.flip%(2*PI)>PI/2 && pos.flip%(2*PI)<3*PI/2)?ImageIO.read(cardImage()):ImageIO.read(backCardImage)).getScaledInstance(wc, hc, 0); + t.setToTranslation(pos.x, pos.y); + t.rotate(pos.a+PI/2); + t.scale(1,abs(cos(pos.flip))); + t.translate(-abs(cos(pos.flip))*wc/2, hc/2);//recentrage + + + + g.drawImage(img, t, null); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public File cardImage() { + //System.err.println(type); + return new File(tempCardsPNGFolder, "card"+type + ".png"); + } + + public static final class Pos{ + public double x,y,a; + public double flip;//-pi/2 to pi/2 : endroit + // autre : envers + + public Pos(double x, double y, double flip, double a) { + this.x = x; + this.y = y; + this.flip = flip; + this.a = a; + } + + @Override + public String toString() { + return "Pos [x=" + x + ", y=" + y + ", a=" + a + ", flip=" + flip + "]"; + } + + + + + } + + +} diff --git a/src/com/bernard/bataille/CardType.java b/src/com/bernard/bataille/CardType.java new file mode 100644 index 0000000..31ce8a0 --- /dev/null +++ b/src/com/bernard/bataille/CardType.java @@ -0,0 +1,5 @@ +package com.bernard.bataille; + +public enum CardType { + +} diff --git a/src/com/bernard/bataille/Component.java b/src/com/bernard/bataille/Component.java new file mode 100644 index 0000000..9b5212c --- /dev/null +++ b/src/com/bernard/bataille/Component.java @@ -0,0 +1,67 @@ +package com.bernard.bataille; + +import java.awt.Graphics2D; +import java.awt.image.BufferedImage; +import java.awt.image.ColorModel; +import java.awt.image.WritableRaster; + +import com.bernard.bataille.Card.Pos; + +public class Component implements Renderable{ + int[] cards; + Pos[] startPos; + Pos[] destinations; + boolean visible; + int wc,hc; + + + + + + public Component(int[] cards, Pos[] startPos, Pos[] destinations, boolean visible, int wc, int hc) { + this.cards = cards; + this.startPos = startPos; + this.destinations = destinations; + this.visible = visible; + this.wc = wc; + this.hc = hc; + for (int i = 0; i < destinations.length; i++) { + if(visible) { + this.startPos[i].flip = 0.; + this.destinations[i].flip = Math.PI; + }else { + this.startPos[i].flip = 0.; + this.destinations[i].flip = 0.; + } + } + } + + public BufferedImage[] render(BufferedImage background,int frameCount) { + BufferedImage[] out = new BufferedImage[frameCount]; + + + for (int i = 0; i < frameCount; i++) { + BufferedImage image = deepCopy(background); + Graphics2D g = image.createGraphics(); + for (int j = 0; j < cards.length; j++) { + Pos actual = new Pos( + startPos[j].x + (destinations[j].x-startPos[j].x)*((double)i/(frameCount-1)), + startPos[j].y + (destinations[j].y-startPos[j].y)*((double)i/(frameCount-1)), + startPos[j].flip + (destinations[j].flip-startPos[j].flip)*((double)i/(frameCount-1)), + startPos[j].a + (destinations[j].a-startPos[j].a)*((double)i/(frameCount-1))); + Card c = new Card(cards[j], actual); + c.draw(g,wc,hc); + } + g.dispose(); + out[i] = image; + } + return out; + } + + public static BufferedImage deepCopy(BufferedImage bi) { + ColorModel cm = bi.getColorModel(); + boolean isAlphaPremultiplied = cm.isAlphaPremultiplied(); + WritableRaster raster = bi.copyData(bi.getRaster().createCompatibleWritableRaster()); + return new BufferedImage(cm, raster, isAlphaPremultiplied, null); + } +} diff --git a/src/com/bernard/bataille/Componentizer.java b/src/com/bernard/bataille/Componentizer.java new file mode 100644 index 0000000..45262f2 --- /dev/null +++ b/src/com/bernard/bataille/Componentizer.java @@ -0,0 +1,224 @@ +package com.bernard.bataille; + +import static java.lang.Math.*; + +import java.awt.Graphics2D; +import java.awt.Image; +import java.awt.geom.AffineTransform; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import javax.imageio.ImageIO; + +import com.bernard.bataille.Card.Pos; + +public class Componentizer { + + + private int playerCount; + volatile Pos[] startPoz, endPoz; + volatile Double[] directions;//angle 0-2pi, cercle trigo normal (gauche = 0, haut = pi/2) + public static File backgroundPicture = new File("/home/mysaa/Pictures/tapisPoker.jpg"); + public static BufferedImage backgroundPictureImage; + private int imgw,imgh,wc,wh; + + List renderables; + + /** + * Crée un generateur de composants graphiques + * @param playerCount le nombre de joueurs + * @param wc la largeur d'une carte + * @param wh la hauteur d'une carte + */ + public Componentizer(int playerCount, int wc, int wh) { + try { + backgroundPictureImage = ImageIO.read(backgroundPicture); + } catch (IOException e) { + e.printStackTrace(); + throw new IllegalStateException("Impossible de charger l'image de fond",e); + } + imgw = backgroundPictureImage.getWidth(); + imgh = backgroundPictureImage.getHeight(); + System.out.println(imgw+"---"+imgh); + this.playerCount = playerCount; + renderables = new ArrayList<>(); + this.wc = wc; + this.wh = wh; + pozRechnen(); + } + + + + /** + * @return the renderables + */ + public List getRenderables() { + return renderables; + } + + + + /** + * @return the backgroundPictureImage + */ + public static BufferedImage getBackgroundPictureImage() { + return backgroundPictureImage; + } + + + + private void pozRechnen() { + //TODO + directions = new Double[playerCount]; + startPoz = new Pos[playerCount]; + endPoz = new Pos[playerCount]; + + double alpha = atan((double)imgh/imgw);// L'angle limite du coin + for(int i = 0;i=2*PI-alpha || t=alpha && t < PI-alpha) {//haut + startPoz[i] = new Pos( (imgw/2)+(imgh/2)*tan(PI/2+t), imgh, Double.NaN, t); + }else if(t >= PI-alpha && t < PI+alpha) {//gauche + startPoz[i] = new Pos(0, (imgh/2)+(imgw/2)*tan(PI-t), Double.NaN, t); + }else {//bas + startPoz[i] = new Pos( (imgw/2)-(imgh/2)*tan(t-PI), imgh, Double.NaN, t); + } + + + } + System.out.println(Arrays.toString(startPoz)); + System.out.println(Arrays.toString(endPoz)); + System.out.println("wow"); + } + + public void turn(int[] cards, boolean hidden) { + renderables.add(new Component(cards, startPoz, endPoz, !hidden, wc, wh)); + } + + public void endOfTurn(){ + renderables.add(new CardsBackGetter(startPoz, endPoz, directions)); + } + + public void playerDead(int playerIndex) { + removeIndex(startPoz, playerIndex); + removeIndex(endPoz, playerIndex); + removeIndex(directions, playerIndex); + } + + public T[] removeIndex(T[] in,int index){ + + Object[] result = new Object[in.length - 1]; + System.arraycopy(in, 0, result, 0, index); + System.arraycopy(in, index + 1, result, index, in.length - index - 1); + return (T[]) result; + } + + public static class CardsBackGetter implements Renderable{ + + volatile Pos[] startPoz, endPoz; + volatile Double[] directions;//angle 0-2pi, cercle trigo normal (gauche = 0, haut = pi/2) + + public static final File handImage = new File("/home/mysaa/Pictures/manchette.png"); + public static int wm,hm; + static { + BufferedImage bimg; + try { + bimg = ImageIO.read(handImage); + wm = bimg.getWidth(); + hm = bimg.getHeight(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + + + public CardsBackGetter(Pos[] startPoz, Pos[] endPoz, Double[] directions) { + super(); + this.startPoz = startPoz; + this.endPoz = endPoz; + this.directions = directions; + } + + @Override + public BufferedImage[] render(BufferedImage background, int frameCount) { + + //TODO mains qui ramassent les cartes + // utiliser backgroundPicture + int fCountP1 = frameCount/2; + int fCountP2 = frameCount-fCountP1; + + BufferedImage[] out = new BufferedImage[frameCount]; + + for (int i = 0; i < fCountP1; i++) { + BufferedImage image = Component.deepCopy(background); + Graphics2D g = image.createGraphics(); + for (int j = 0; j < directions.length; j++) { + int x = (int) (startPoz[j].x + (endPoz[j].x-startPoz[j].x)*(i/(fCountP1-1))), + y = (int) (startPoz[j].y + (endPoz[j].y-startPoz[j].y)*(i/(fCountP1-1))); + + try { + AffineTransform t = g.getTransform(); + Image img = ImageIO.read(handImage); + t.setToTranslation(x, y); + t.rotate(directions[j]); + t.translate(wm/2, -hm/2);//recentrage + + g.drawImage(img, t, null); + } catch (IOException e) { + e.printStackTrace(); + } + } + g.dispose(); + out[i] = image; + } + + for (int i = 0; i < fCountP2; i++) { + BufferedImage image; + Graphics2D g; + try { + image = ImageIO.read(backgroundPicture); + g = image.createGraphics(); + } catch (IOException e1) { + e1.printStackTrace(); + return null; + } + for (int j = 0; j < directions.length; j++) { + int x = (int) (startPoz[j].x + (endPoz[j].x-startPoz[j].x)*(1-i/(fCountP2-1))), + y = (int) (startPoz[j].y + (endPoz[j].y-startPoz[j].y)*(1-i/(fCountP2-1))); + + try { + AffineTransform t = g.getTransform(); + Image img = ImageIO.read(handImage); + t.setToTranslation(x, y); + t.rotate(directions[j]); + t.translate(wm/2, -hm/2);//recentrage + + g.drawImage(img, t, null); + } catch (IOException e) { + e.printStackTrace(); + } + } + g.dispose(); + out[fCountP1 + i] = image; + } + + + + return out; + } + + + } + +} diff --git a/src/com/bernard/bataille/CrapoyamsMotor.java b/src/com/bernard/bataille/CrapoyamsMotor.java new file mode 100644 index 0000000..ff5bd7b --- /dev/null +++ b/src/com/bernard/bataille/CrapoyamsMotor.java @@ -0,0 +1,137 @@ +package com.bernard.crapoyams; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class CrapoyamsMotor { + public static int[][] tableDesGains = { + /*Paire*/{0,100,100,200,200,300}, + /*2Paire*/{100,200,300,400,500,600}, + /*Brelan*/{100,300,400,600,700,900}, + /*Carré*/{200,400,600,800,1000,1200}, + /*Full*/{200,500,700,1000,1200,1500}, + /*Petite suite*/{5000}, + /*Grande suite*/{25000}, + /*Quinte*/{60000,60000,60000,60000,60000,60000} + }; + public static int déFaces = 6; + + public static void main(String[] args) { + int nombreLancers = 100000000; + int[] vals = new int[nombreLancers]; + for (int n = 1;n < nombreLancers; n++) { + int[] dés = new int[] { + (int)(Math.random()*6+1), + (int)(Math.random()*6+1), + (int)(Math.random()*6+1), + (int)(Math.random()*6+1), + (int)(Math.random()*6+1) + }; + vals[n] = gain(dés); + System.out.println(n+":"+Arrays.toString(dés)+"->"+vals[n]); + } + System.out.println("==>"+moyenne(vals)); + } + + public static int évaluer(int[] dés) { + double[] éspérances = new double[0b100000]; + for (int i = 0; i < éspérances.length; i++) + éspérances[i] = espérance(dés, i); + List bestMélanges = new ArrayList<>(); + double perfection = highest(éspérances); + int pos; + while((pos = indexOf(éspérances, perfection)) != -1) { + éspérances[pos] = Double.NaN; + bestMélanges.add(pos); + } + System.out.println(perfection); + return bestMélanges.get(0); + } + + public static double espérance(int[] dés, int mélange) { + if(mélange == 0b00000) {//Aucun mélange, donc l'espérance est le gain réel + double gain = gain(dés); + //System.out.println(Arrays.toString(dés)+" -> " + gain); + return gain; + }else { + int pos = 0; + while((mélange >> pos) % 2 == 0)pos++; + double[] espérances = new double[déFaces]; + mélange -= 0b1 << pos; + int[] shuffledDés = Arrays.copyOf(dés, dés.length); + for (int tirage = 1; tirage < déFaces + 1; tirage++) { + shuffledDés[pos] = tirage; + espérances[tirage-1] = espérance(shuffledDés, mélange); + } + return moyenne(espérances); + + } + } + + public static final int gain(int[] dés) { + Arrays.sort(dés); + int[] counts = new int[déFaces]; + Arrays.fill(counts, 0); + for (int i : dés) counts[i-1]++; + int pos = -1; + + /* Traitement des cas */ + if(Arrays.equals(dés, new int[] {1,2,3,4,5})) + return tableDesGains[6][0]; + else if(Arrays.equals(dés, new int[] {0,1,2,3,4})) + return tableDesGains[5][0]; + else if((pos = lastIndexOf(counts,5)) != -1) + return tableDesGains[7][pos]; + else if((pos = lastIndexOf(counts,4)) != -1) + return tableDesGains[3][pos]; + else if((pos = lastIndexOf(counts,3)) != -1) + if(lastIndexOf(counts,2) == -1) + return tableDesGains[2][pos]; + else + return tableDesGains[4][pos]; + else if((pos = lastIndexOf(counts,2)) != -1) + if(indexOf(counts,2) == pos) + return tableDesGains[0][pos]; + else + return tableDesGains[1][pos]; + else + return 0;//Aucune combinaison + } + + public static final int lastIndexOf(int[] array, int element) { + for (int i = array.length -1; i >= 0; i--) + if(element == array[i])return i; + return -1; + } + public static final int indexOf(int[] array, int element) { + for (int i = 0; i < array.length; i++) + if(element == array[i])return i; + return -1; + } + public static final int indexOf(double[] array, double element) { + for (int i = 0; i < array.length; i++) + if(element == array[i])return i; + return -1; + } + public static final double moyenne(double[] valeurs) { + double moyenne = 0; + for (double d : valeurs) + moyenne += d; + return moyenne/((double)valeurs.length); + } + public static final double moyenne(int[] valeurs) { + double moyenne = 0; + for (double d : valeurs) + moyenne += d; + return moyenne/((double)valeurs.length); + } + public static final double highest(double[] valeurs) { + if(valeurs.length == 0)throw new IllegalArgumentException("valeurs ne doit pas etre vide !"); + double current = valeurs[0]; + for (double d : valeurs) + if(d > current) + current = d; + return current; + } +} diff --git a/src/com/bernard/bataille/GameManager.java b/src/com/bernard/bataille/GameManager.java new file mode 100644 index 0000000..e116bf3 --- /dev/null +++ b/src/com/bernard/bataille/GameManager.java @@ -0,0 +1,159 @@ +package com.bernard.bataille; + +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import java.util.Random; +import java.util.Set; + +import javax.imageio.ImageIO; + +public class GameManager { + List> cartes; + List> defausses; + int alivePlayers; + Random shuffler; + + public static void main(String[] args) { + Componentizer c = new GameManager(2,2).game(); + List l = c.getRenderables(); + BufferedImage bg = Componentizer.getBackgroundPictureImage(); + try { + for (int i = 0; i < l.size(); i++) { + System.out.println(l.get(i)); + if(l.get(i) instanceof Componentizer.CardsBackGetter)continue; + BufferedImage[] imgs = l.get(i).render(bg, 10); + System.out.println(Arrays.toString(imgs)); + for (int j = 0; j < imgs.length; j++) { + ImageIO.write(imgs[j], "png", new File("/tmp/bataille/","img_"+i+"_"+j+".png")); + } + bg = imgs[imgs.length-1]; + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + public GameManager(int playerCount,int packetCount) { + this.alivePlayers = playerCount; + shuffler = new Random(); + cartes = new ArrayList<>(); + defausses = new ArrayList<>(); + for (int i = 0; i < playerCount; i++) { + cartes.add(new LinkedList<>()); + defausses.add(new LinkedList<>()); + } + List pioche = new ArrayList<>(); + for(int i = 0;i<13*4;i++)pioche.addAll(Collections.nCopies(packetCount, i)); + Collections.shuffle(pioche, shuffler); + for (int i = 0; i < pioche.size(); i++) + cartes.get(i%playerCount).add(pioche.get(i)); + + } + + public Componentizer game() { + Componentizer componentizer = new Componentizer(alivePlayers,50,78); + while(alivePlayers > 1) { + + int[] upTable = new int[alivePlayers]; + List winners = new ArrayList<>(); + Set pot = new HashSet<>(); + Integer highest = 0; + boolean flipped = false; + + while(winners.size() != 1) {// Tant que bataille + + if(alivePlayers == 1) break; + + //Fix dead people + fixCards(); + for (int i = 0; i < alivePlayers; i++) { + if(cartes.get(i).isEmpty()) { + System.out.println("Le joueur "+i+" nous a quitté ... tout le monde s'en faut de toute façon !"); + componentizer.playerDead(i); + alivePlayers--; + int[] oldUpTable = upTable; + upTable = new int[alivePlayers]; + System.arraycopy(oldUpTable, 0, upTable, 0, i); + System.arraycopy(oldUpTable, i+1, upTable, i, alivePlayers-i); + cartes.remove(i); + defausses.remove(i); + } + } + + highest = 0; + for (int i = 0; i < upTable.length; i++) { + upTable[i] = cartes.get(i).poll(); + pot.add(upTable[i]); + highest = (highest > upTable[i]%13)?highest:upTable[i]%13; + } + System.out.println(alivePlayers+" joueurs jouent : "+cardArrayToString(upTable) + (flipped?" (caché)":"")); + componentizer.turn(upTable, flipped); + winners.clear(); + if(!flipped) + for (int i = 0; i < upTable.length; i++) + if(upTable[i]%13==highest)winners.add(i); + + + flipped = !flipped; + } + if(alivePlayers > 1) { + componentizer.endOfTurn(); + System.out.println("GG au joueur "+winners.get(0)); + defausses.get(winners.get(0)).addAll(pot); + } + } + return componentizer; + } + + public void fixCards() { + for (int i = 0; i < alivePlayers; i++) { + if(cartes.get(i).isEmpty()) { + Collections.shuffle(defausses.get(i), shuffler); + cartes.get(i).addAll(defausses.get(i)); + defausses.get(i).clear(); + } + } + } + + public static final String cardToString(int i) { + String color = ""; + switch(i/13) { + case 0:color="♠";break; + case 1:color="♣";break; + case 2:color="♥";break; + case 3:color="♦";break; + } + switch(i%13) { + case 0 : return "2"+color; + case 1 : return "3"+color; + case 2 : return "4"+color; + case 3 : return "5"+color; + case 4 : return "6"+color; + case 5 : return "7"+color; + case 6 : return "8"+color; + case 7 : return "9"+color; + case 8 : return "X"+color; + case 9 : return "V"+color; + case 10 : return "D"+color; + case 11 : return "R"+color; + case 12 : return "A"+color; + } + return ""; + } + + public static final String cardArrayToString(int[] cards) { + String out = ""; + for (int i : cards) + out+="|"+cardToString(i); + return out.substring(1); + } + +} diff --git a/src/com/bernard/bataille/Renderable.java b/src/com/bernard/bataille/Renderable.java new file mode 100644 index 0000000..36d48c7 --- /dev/null +++ b/src/com/bernard/bataille/Renderable.java @@ -0,0 +1,7 @@ +package com.bernard.bataille; + +import java.awt.image.BufferedImage; + +public interface Renderable { + public BufferedImage[] render(BufferedImage background,int frameCount); +}