public void deleteMe() { // Although raids are not removed from the sql server, their supporting au should be. They are // merely placeholders // and will either survive or goto zero, besides, the statreports exist to tell the true story. // By placeholders I mean they are like extra au fields for the raid, the actual // data is held on the supportAU table. try { int k = 6; UberStatement stmt = con.createStatement(); ArrayList<AttackUnit> au = getAu(); // stmt.executeUpdate("update raid set ticksToHit=-1 where rid = " + raidID); setTicksToHit(-1); save(); // save the current state right before deletion. while (k < au.size()) { stmt.executeUpdate( "delete from raidSupportAU where tid = " + getTown1().townID + " and rid = " + raidID + " and tidslot = " + au.get(k).getSlot() + ";"); k++; } stmt.close(); getTown1().attackServer().remove(this); // and we remove it from memory.... } catch (SQLException exc) { exc.printStackTrace(); } }
public ArrayList<AttackUnit> getAu() { if (au == null) { int y = 0; ArrayList<AttackUnit> raidAU = new ArrayList<AttackUnit>(); AttackUnit auHold; ArrayList<AttackUnit> tau = getTown1().getAu(); while (y < 6) { auHold = tau.get(y).returnCopy(); if (getSupport() == 1 && getTown1().getPlayer().ID != getTown2().getPlayer().ID) { auHold.makeSupportUnit(auHold.getSlot(), getTown1().getPlayer(), getTown1().townID); } else if (getSupport() == 2 && getTown1().getPlayer().ID != getTown2().getPlayer().ID) auHold.makeOffSupportUnit(auHold.getSlot(), getTown1().getPlayer(), getTown1().townID); auHold.setSize(getInt("au" + (y + 1))); raidAU.add(auHold); y++; } try { UberStatement rustown2 = con.createStatement(); ResultSet rrs2 = rustown2.executeQuery( "select * from raidSupportAU where rid = " + raidID + " and tid = " + getTown1().townID + " order by tidslot asc"); AttackUnit sAU; while (rrs2.next()) { int size = rrs2.getInt(4); // right we have what we need, we know // we already have a reference to town1... int j = 6; boolean found = false; while (j < tau.size()) { if (tau.get(j).getSlot() == rrs2.getInt(3)) { sAU = tau.get(j).returnCopy(); // attackunits are already on town 1, so they were ported // here, just need sizes! sAU.setSize(size); raidAU.add(sAU); } j++; } } rrs2.close(); rustown2.close(); au = raidAU; } catch (SQLException exc) { exc.printStackTrace(); } } return au; }
public void setString(String fieldName, String toSet) { try { UberStatement stmt = con.createStatement(); stmt.execute("update raid set " + fieldName + " = \"" + toSet + "\" where rid = " + raidID); stmt.close(); } catch (SQLException exc) { exc.printStackTrace(); } }
public void add(AttackUnit j) { // THIS IS ONLY FOR DB USAGE... // getAu().add(j); UberStatement stmt; try { stmt = con.createStatement(); // First things first. We update the player table. boolean transacted = false; while (!transacted) { try { stmt.execute( "start transaction;"); // it's logged in, starts transaction so data problems won't // happen. // let's add this raid and therefore get the rid out of it. if (j.getSlot() < 6) { stmt.executeUpdate( "update raid set au" + (j.getSlot() + 1) + " = " + j.getSize() + " where rid = " + raidID + ";"); } else { stmt.executeUpdate( "insert into raidSupportAU (rid,tid,tidslot,size) values (" + raidID + "," + getTown1().townID + "," + j.getSlot() + "," + j.getSize() + ");"); // don't need original slot, need // current town slot for remembering! } stmt.execute("commit;"); stmt.close(); transacted = true; } catch (MySQLTransactionRollbackException exc) { System.out.println(raidID + " is having trouble adding units."); } } } catch (SQLException exc) { exc.printStackTrace(); } }
public String getString(String toGet) { try { UberStatement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("select " + toGet + " from raid where rid = " + raidID); rs.next(); String toRet = rs.getString(1); rs.close(); stmt.close(); return toRet; } catch (SQLException exc) { exc.printStackTrace(); } return null; }
public void setMemSize(int index, int size) { if (index < 6) setInt("au" + (index + 1), size); else { try { UberStatement stmt = con.createStatement(); AttackUnit a = getAu().get(index); stmt.executeUpdate( "update raidSupportAU set size = " + size + " where tidslot = " + a.getSlot() + " and rid = " + raidID + " and tid = " + getTown1().townID); stmt.close(); } catch (SQLException exc) { exc.printStackTrace(); System.out.println("Your shit is a-okay."); } } }
public Raid( double distance, int ticksToHit, Town town1, Town town2, boolean Genocide, boolean Bomb, int support, boolean invade, String name, boolean debris, ArrayList<AttackUnit> au, int digAmt) { // Can't do an infinite number of arguments here so need to add manually. // holds distance and ticksToHit in this object. this.setInvade(invade); this.setSupport(support); this.setDebris(debris); this.digAmt = digAmt; this.setName(name); this.au = au; this.setDistance(distance); this.setTicksToHit(ticksToHit); if (distance == 0) distance = 1; God = town1.getPlayer().God; this.setBomb(Bomb); this.setTown2(town2); this.setTown1(town1); setRaidOver(false); this.setTotalTicks(ticksToHit); this.setGenocide(Genocide); if (Genocide) setAllClear( false); // Note you need to watch in loaded raids, that raidOver and allClear need to be // set manually. // player1 hits player2's town2, only need town2 to access units. UberStatement stmt; try { con = town1.getPlayer().God.con; stmt = con.createStatement(); // First things first. We update the player table. boolean transacted = false; while (!transacted) { try { stmt.execute( "start transaction;"); // it's logged in, starts transaction so data problems won't // happen. // let's add this raid and therefore get the rid out of it. stmt.executeUpdate( "insert into raid (tid1, tid2, distance, ticksToHit, genocide, raidOver,allClear,m,t,mm,f,totalTicks,Bomb,support,invade,name,debris,digAmt) values (" + town1.townID + "," + town2.townID + "," + distance + "," + ticksToHit + "," + Genocide + "," + false + "," + false + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + ticksToHit + "," + Bomb + "," + support + "," + invade + ",\"" + name + "\"," + debris + "," + digAmt + ");"); stmt.execute("commit;"); Thread.currentThread().sleep(10); ResultSet ridstuff = stmt.executeQuery( "select rid from raid where tid1 = " + town1.townID + " and raidOver = false"); /* *Okay, search out all raids on the db for this town, and compare them to the raid server that the town has. There should be an rid *corresponding to each raid on there, and one that isn't. This one is our rid. *Now, if the user is running concurrent threads and they both call to this to add the raid at the same time, then there will be two *separate raidIDs on there. Still something of a problem, but we have to acknowledge the quickness of this maneuver - this thing will *literally be lightning quick. It'll snatch up that rid and add this one to the server without a hesitation. *if there is a problem, we can always assign a huge random number tempid to it, and use that as an extra comparison. If the user *does do two things at once, two raids, then I have to ask - what is the problem with switching the rids up? You see, if he does manage *to do it on the same town at the same time within a time frame that would allow both to be unaccounted for at the same time, then as soon *as the rids are switched, the player object would update them both with correct values from us. There we go. It happens so quickly. */ while (ridstuff.next()) { int j = 0; ArrayList<Raid> attackServer = town1.attackServer(); while (j < attackServer.size()) { if (attackServer.get(j).raidID == ridstuff.getInt(1)) break; j++; } if (j == attackServer.size()) break; // means we found no raid accompanying this raidID. } raidID = (ridstuff.getInt(1)); // town1.attackServer.add(this); // <---- THIS NEEDS TO BE RETURNED TO NORMAL IF YOU GO // BACK TO MEMORYLOADING! // System.out.println("I put on " +raidID); town1.attackServer().add(this); // even if this error happens, raid still works... ridstuff.close(); stmt.execute("commit;"); /* int timesTried = 0; ArrayList<Raid> a = town1.attackServer(); while(a.size()<=0&×Tried<10) { Thread.currentThread().sleep(10); a= town1.attackServer(); timesTried++; } raidID=a.get(a.size()-1).raidID;*/ stmt.close(); transacted = true; } catch (MySQLTransactionRollbackException exc) { } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } // need connection for attackunit adds! } catch (SQLException exc) { exc.printStackTrace(); } }
public Raid(int raidID, GodGenerator God) { this.raidID = raidID; this.God = God; this.con = God.con; try { UberStatement rus = con.createStatement(); ResultSet rrs = rus.executeQuery("select * from raid where rid = " + raidID); // so we don't want it to load if raidOver is true and ticksToHit is 0. Assume 0 is not, 1 is // on, for ttH. !F = R!T // Then F = !(R!T) = !R + T; while (rrs.next()) { // First, to seek out town 2, use a query! Town town1 = God.findTown(rrs.getInt(1)); Town town2Obj = God.findTown(rrs.getInt(2)); // double distance = Math.sqrt((town2Obj.x-Town1.x)*(town2Obj.x-Town1.x) + // (town2Obj.y-Town1.y)*(town2Obj.y-Town1.y)); // // public Raid(int raidID, double distance, int ticksToHit, Town town1, Town town2, boolean // Genocide,boolean allClear, // int metal, int timber, int manmat, int food,boolean raidOver,ArrayList<AttackUnit> au, // boolean Bomb) { int y = 0; setRaidValues( rrs.getInt(3), rrs.getDouble(4), rrs.getInt(5), town1, town2Obj, rrs.getBoolean(6), rrs.getBoolean(8), rrs.getInt(9), rrs.getInt(10), rrs.getInt(11), rrs.getInt(12), rrs.getBoolean(7), rrs.getBoolean(19), rrs.getBoolean(23), rrs.getInt(25), rrs.getString(26), rrs.getInt(27), rrs.getBoolean(28), rrs.getInt(29)); // this one has no sql addition! getAu(); if (rrs.getBoolean(19)) bombTarget = rrs.getInt(20); if (rrs.getInt(21) == 1 && !rrs.getBoolean(7)) makeSupportRun(); else if (rrs.getInt(21) == 2 && !rrs.getBoolean(7)) makeOffSupportRun(); else if (rrs.getInt(22) == 1 && !rrs.getBoolean(7)) makeScoutRun(); else if (rrs.getInt(22) == 2 && !rrs.getBoolean(7)) makeDiscoveredScoutRun(); if (rrs.getInt(24) != -1 && !rrs.getBoolean(7)) setResupplyID(rrs.getInt(24)); } rrs.close(); rus.close(); } catch (SQLException exc) { exc.printStackTrace(); } /* this.distance=getMemDistance(); this.ticksToHit=getMemTicksToHit(); getTown1(); getTown1(); this.Genocide=isMemGenocide(); this.allClear=isMemAllClear(); this.metal=getMemMetal();this.timber=getMemTimber();this.manmat=getMemManmat();this.food=getMemFood(); this.raidOver=isMemRaidOver();getAu();this.Bomb=isMemBomb();this.invade=isMemInvade(); this.totalTicks=getMemTotalTicks();this.name=getMemName();this.genoRounds=getMemGenoRounds();*/ // we set nothing else! }
public Raid( int raidID, double distance, int ticksToHit, Town town1, Town town2, boolean Genocide, boolean allClear, int metal, int timber, int manmat, int food, boolean raidOver, ArrayList<AttackUnit> au, boolean Bomb, boolean invade, int totalTicks, String name, int genoRounds, boolean debris, int digAmt) { // This constructor does not use the support integer because it is rarely used compared to other // things // and so to save space that is exported as an extra usable method. It is only necessary // when creating raids. // this constructor is for when a raid is being loaded into memory. if (distance == 0) distance = 1; this.digAmt = digAmt; this.setDebris(debris); this.distance = distance; this.ticksToHit = ticksToHit; this.town1 = town1; this.town2 = town2; this.Genocide = Genocide; this.allClear = allClear; this.metal = metal; this.timber = timber; this.manmat = manmat; this.food = food; this.raidOver = raidOver; this.au = au; this.Bomb = Bomb; this.invade = invade; this.totalTicks = totalTicks; this.name = name; this.genoRounds = genoRounds; UberStatement stmt; try { con = town1.getPlayer().God.con; God = town1.getPlayer().God; stmt = con.createStatement(); // First things first. We update the player table. boolean transacted = false; while (!transacted) { try { stmt.execute( "start transaction;"); // it's logged in, starts transaction so data problems won't // happen. // let's add this raid and therefore get the rid out of it. stmt.executeUpdate( "insert into raid (tid1, tid2, distance, ticksToHit, genocide, raidOver,allClear,m,t,mm,f,totalTicks,Bomb,invade,name,genoRounds,digAmt) values (" + town1.townID + "," + town2.townID + "," + distance + "," + ticksToHit + "," + Genocide + "," + false + "," + false + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + ticksToHit + "," + Bomb + "," + invade + ",\"" + name + "\"," + genoRounds + "," + digAmt + ");"); stmt.execute("commit;"); Thread.currentThread().sleep(10); ResultSet ridstuff = stmt.executeQuery( "select rid from raid where tid1 = " + town1.townID + " and raidOver = false"); while (ridstuff.next()) { int j = 0; ArrayList<Raid> attackServer = town1.attackServer(); while (j < attackServer.size()) { if (attackServer.get(j).raidID == ridstuff.getInt(1)) break; j++; } if (j == attackServer.size()) break; // means we found no raid accompanying this raidID. } raidID = (ridstuff.getInt(1)); // town1.attackServer.add(this); // <---- THIS NEEDS TO BE RETURNED TO NORMAL IF YOU GO // BACK TO MEMORYLOADING! // System.out.println("I put on " +raidID); ridstuff.close(); /* Thread.currentThread().sleep(100); int timesTried = 0; ArrayList<Raid> a = town1.attackServer(); while(a.size()<=0&×Tried<1000) { // we wait longer for raids...f*****g a raid up is really bad...REALLY. // because we add shit to it after it is made! Of course, could f**k up oppositely, and take a raid already // on there and add shit to it, either way, bad for biz. So we wait 100ms before we even try. Thread.currentThread().sleep(10); a= town1.attackServer(); timesTried++; } raidID=a.get(a.size()-1).raidID;*/ int i = 0; while (i < au.size()) { add(au.get(i)); i++; } stmt.close(); transacted = true; } catch (MySQLTransactionRollbackException exc) { } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } // need connection for attackunit adds! } catch (SQLException exc) { exc.printStackTrace(); } }
public synchronized void save() { try { UberStatement stmt = con.createStatement(); ArrayList<AttackUnit> au = getAu(); if (getTown1().townID == 3569) System.out.println("I am raid " + raidID); String update = ""; try { update = "update raid set distance = " + distance + ", ticksToHit = " + ticksToHit + ", genocide = " + Genocide + ", raidOver = " + raidOver + ", allClear = " + allClear + ", m = " + metal + ", t = " + timber + ", mm = " + manmat + ", f = " + food + ", au1 = " + au.get(0).getSize() + ", au2 = " + au.get(1).getSize() + ", au3 = " + au.get(2).getSize() + ", au4 = " + au.get(3).getSize() + ", au5 = " + au.get(4).getSize() + ", au6 = " + au.get(5).getSize() + ", bomb = " + Bomb + ", bombtarget = " + bombTarget + ", support = " + support + ", scout = " + scout + ", invade = " + invade + ", resupplyID = " + resupplyID + ", totalTicks = " + totalTicks + " where rid = " + raidID + ";"; } catch (IndexOutOfBoundsException exc) { exc.printStackTrace(); System.out.println("Found"); } stmt.executeUpdate(update); int k = 6; while (k < au.size()) { stmt.executeUpdate( "update raidSupportAU set size = " + au.get(k).getSize() + " where tid = " + town1.townID + " and rid = " + raidID + " and tidslot = " + au.get(k).getSlot() + ";"); k++; } stmt.close(); // either being added back to town or was completely wiped out, either way, should be removed // from memory. } catch (SQLException exc) { exc.printStackTrace(); } }