def AI_loop(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(45) sendData = getSendData() output = getOutput(sendData, 12, 5, 2, weight) turn, thrust = "N", "N" if output[0] >= .55: ai.turnRight(1) turn = "R" elif output[0] < .45: ai.turnLeft(1) turn = "L" ai.setTurnSpeed(abs(output[0]-.5)*100) if output[1] > random(): ai.thrust(1) thrust = "Y" if ai.selfAlive(): print (turn +" "+ str(round(output[0],3)) +" | "+ thrust +" "+ str(round(output[1],3)))
def AI_loop(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(45) #noshoot simple2 v1 - possibly broken #weight = [[0.7493857316521443, 0.13368056995306654, -0.47767010506248414, 0.36303490376111747, 0.3699402939846066, -0.24513421555956436, 0.6049213422682447, -1.002771350490762, 0.04035249957935825, -0.28434589370049973, 0.06045481719428707, -0.7059773487995405], [0.4597751718875, 0.48527265677711917, 1.1633270644302531, -0.2617787944640836, 0.43969814249154665, 0.39105202732983013, -0.4842763268769806, 0.0139642821717396, 0.6316767202549712, -0.7261062652316246, 0.21262210805420517, 0.5641099350636366], [-0.3874172140692371, 0.7651295146994167, 1.0395098788413182, 1.186226846675026, -0.025235379424306762, 0.2946735626872294, 0.8189904988668917, -0.3112836835374087, 0.4561011502092862, -1.117805735032487, -0.43961810490175446, -0.4119472393430895], [0.22275511634133816, -0.6648437205568158, -0.8414740640064268, 0.8056440111521608, 0.015267716015499746, 0.41334996924272127, 0.4081963555038903, -0.1419511839287509, 0.45361416054410414, -0.8794849582102071, -0.3468746833944422, 0.5401415708615188], [0.5074970117306209, 0.5819675141877677, 0.6517899284876814, 0.46691400605473293, 0.32604510520447944, 0.5968926122763236, 0.5310482664503053, -0.680392116654488, 0.8673231237747582, 0.33285892719317295, 0.8399077545012879, 0.6164215093257798], [-0.372562013299741, -0.19652620269354013, 0.1437357080878078, 0.4658598892474184, 0.2622911587442708, -0.0978653491300881], [-0.8758502232674676, -0.2171515591378693, -2.993752695121232, -0.35299785185297505, 0.23130479682141922, -0.3366867315248932]] #same #weight = [[-0.5615458044552419, 0.18357035281974562, 0.03349259503126993, 0.7384951638825633, -0.30798810007905386, 0.30573186272807085, 0.854959406907431, -0.7415861859492735, -0.7738387875893121, 0.02855354677310282, -0.851478966174285, -0.4098017778685181], [-0.207370684933253, -0.013364767376613134, -0.9163625758710611, 0.7147484720369136, 0.4332939609435104, 0.08179173241171495, -0.7872472562071717, -0.028481692524635203, 0.9018021433254303, 0.44174414866442663, -0.9254417448428363, -0.8782722048252558], [0.33830929947647237, 0.3662059060118147, 0.3811711776833437, 0.24042392561994674, 0.5277499126295441, -0.0004866655690337176, 0.25640579185352463, -0.7633986561071578, -0.612156341670209, 0.8230711072150679, 0.760953671186351, -0.2573796666700781], [-0.504034389497162, -0.5579761993837166, -0.5804468446739354, 0.20559197382639358, 0.2633102441141902, 0.6523171620389138, -0.024442707325193276, 0.20991650483980787, 0.8242995112997102, -0.310268650118638, 0.6134846337134139, -0.1333594123873779], [-0.1482061081648374, -0.8156028525698128, 0.5620698705963493, 0.3369535386843364, 0.4950101349517008, 0.632041030208815, 0.2282786987810209, 0.5886322102158713, 0.1479714498784525, -0.35843514023521145, 0.7822417167093876, -0.6863908492221918], [0.19475966937630487, 0.3329038845401951, -0.4194515125286082, -1.0059783572483236, 0.4401534681618835, -0.14131035905437314], [-0.1489506388852606, -0.7142411448348961, 0.19491176823686687, -0.7258125795197734, -0.5016315182547347, 1.187683861246764]] #noshoot simple2 v1 #weight = [[4.023914862289385, -11.939688383204079, -15.825568188856662, -8.91142185823263, 2.641203914119205, -0.5129014819329881, 0.9220419943089314, 0.3895906088166904, -3.314207628630927, 1.467458787811278, 1.0256723985314264, 6.790853759075572], [0.46927642890835647, 0.4119664313516612, 1.0805195819839035, -22.587191583019706, -2.0569865767257087, 1.0122406403957074, 0.7655020473448081, 0.5363534804959299, -0.09153880599832058, 1.742638802899449, 0.604362216981221, -5.437549122082703], [-7.860553953097792, 8.381751807757572, 16.129268910929408, 0.8192147369369929, 12.621334155351937, 1.1871517887014937, 1.3270695309760896, 1.0735505581082165, -2.1305919492192547, 0.8033262515099523, 3.3317152348735313, -1.1046970930734303], [0.4398449547641411, 1.912802187200376, 1.5190820053279013, 0.05054235950852018, 20.89903152269866, -5.003395008994748, -2.6880139668653324, -7.882075146152547, 7.312459204984362, 0.7725581247271933, -3.2005214579831134, 8.556187322708842], [-1.293677418426306, 1.0762585514923537, 2.9472553959491394, -2.8811018920854745, 20.39410027291124, 3.5575387211971545, -4.928681592073799, 3.91012465174139, -0.6466184042394076, 8.419255646279453, -8.094268776239682, 19.5220882165644], [0.3806641134895386, -0.054247151061047154, 0.35553915476967757, -0.16909223457447353, 0.6749672736601655, -0.19785778477211138], [6.21846263437043, 13.27919055895352, 5.556186398879765, 1.9758063219353386, 3.685290720905768, 11.4029046390971]] #weight = [[0.5903138120766798, 0.3877986755669686, -0.9141386987535192, -0.1976691845132495, 0.20203743452617146, -3.8075577538969068, 13.355367631879064, -4.451492883287705, -4.077459994350015, -2.8670604965816433, -4.7237141988262215, 4.196577955775335], [0.05788957126040142, 0.7553202993193877, -0.41293776536874083, 0.9699420358471046, -0.39940905986885467, -0.7501531314002139, -3.649664715012045, -4.480417131687637, 12.40189634710716, -3.5479446525980323, -5.617634895580113, 4.614443478920718], [-0.44964748196431087, -0.21623652235598786, 0.5866855307562749, 2.6966017037464547, -0.2198767358187771, -15.121568447637916, 5.394174355851121, 3.3357101263144284, 5.142941080162113, 4.396587735322672, 6.27965132359125, -1.7132992179558508], [-0.8420976477874832, 3.6695944609982, 3.985187073998181, 11.839206173737303, -5.338358329529615, 12.584411691032383, -3.6258238911963225, -9.100219517619708, 0.09757837890948427, 0.26347032883307564, -2.317810633312963, 3.488522703736898], [0.7765991306851521, 0.28898396896441564, 0.7418514532805458, 7.79799228304993, -0.19002509820555794, -0.4950254716867189, 1.674108868938578, -2.550479398095525, -0.4777881148214889, -17.68616848936312, 17.798127474785755, 3.564677234214063], [-7.8104601458246075, -2.0636289766378315, -8.171829518484577, -0.3002860633762538, -0.8003364861508999, -8.88545431866241], [-9.931271155016605, -8.304191180682096, -4.721651527085654, -11.413401995134363, -6.807105641677094, -4.2517323859898255]] #take 3 #weight = [[3.2209677211590364, 3.197844521358916, 1.0178700774531555, 2.6850832852265705, -0.1142410857208976, -7.424760693950065, 2.4741068398654735, -2.2455337118424423, 0.7975567187947812, -7.14879174218826, 1.1236926484785208, 1.0893799362829708], [0.8039483127966134, 2.0360025213584287, 0.01727196345640146, 13.743242184336747, -3.1131725731697797, 3.551772323183245, -1.912134715951023, 6.3466547648380365, 2.7583972445682843, -8.543348277242536, 1.0695972197298327, 1.0968548560479523], [-1.9711628616688408, -2.915258703528061, -0.6856763056229077, 5.775022292258987, -0.9242292134264676, -5.2290301586614545, 1.554497111395412, -8.663422012897401, 3.434867742464676, -1.4626063376098368, 3.1916811250980226, -3.1266957996982083], [-2.963581011499582, -1.8333571215071727, 0.19431283257511642, 12.685505979633772, 5.629563357825744, 2.269402859201827, -0.5394798674782302, 0.5415330617135145, -1.3492223641876873, -2.3782036784139104, -1.6868806998589756, -2.566848157895665], [-2.1971772106385568, -3.046613937692231, -1.91992660803775, 6.63802500331367, -13.090973918413972, 2.0019783380453955, 1.5786044885623458, -1.1226639661286304, -0.8816140948702889, -0.6041236731069092, 0.4128577493527515, -9.236718652388456], [-0.37898780078879885, 0.02278416261917311, -0.7370299412447531, 0.4580826382451188, 0.024909816638153417, -0.2986982689652905], [-6.204456817434451, -7.054321617074455, -3.8731103597961956, -7.0447149929917146, -6.223052160580929, -15.546591666508577]] #weight = [[1.1620356523045294, 1.2293119820243932, -1.0680281171990968, -5.292742962549776, 3.004567388617913, 0.1416865776270463, 3.291787739904783, 3.311779449153159, 0.14350525985680226, 1.864065320111765, 0.41531949262324336, -0.7533626568752921], [2.6058003821118527, 0.9844458916296726, -2.031523030007777, -3.4422006288675315, 4.5638626155289055, -2.7046080365173837, 1.5356155037759958, 2.143460607268979, 3.9199241782825687, 0.12721742246873802, -0.8673469875291382, -1.8507505784965346], [-0.6131784294183935, 0.4639547932071712, -0.2666315961058117, 7.5292821094228755, -1.087211170794136, -0.7293843967199962, 0.4755491742014118, 0.4206888297192853, -0.8152826105125003, 1.988359326013337, -5.637090150274117, 0.5993755933965147], [0.27691971567025647, 1.037850843325554, -0.8250576728298599, -2.000417570912899, -0.006391527390813737, 2.0837950209487466, -8.24238052083867, 2.073287983133908, 3.2529633929820907, 2.1453759622986524, 3.7417070714472893, -2.9435663281508724], [-0.5037569895779601, -0.09031006667126633, -0.5311072081881074, 0.9440264182616986, 0.783774066571815, 6.828375559954358, -2.841644500387658, 0.24901014690965492, -4.849174297326825, -1.5945524577293186, -4.823283932380879, 1.1962232130136108], [1.4042452333993327, -0.09263191061453735, 0.8155734671747938, 5.256825832477101, 3.7371321136701705, 6.574206973322576], [13.323880256265307, -2.429025764741311, -10.985707613602697, 5.331771733353978, -0.12615902379461702, 15.191420141027539]] #take 4 #weight = [[0.1906964794417142, -1.3230251087714693, -1.8568527275491726, -10.570510924730712, 0.3754935945207968, -4.767279359714083, 0.11809759894653031, -6.033443845654109, -4.862563766686397, -1.5992520992754746, 7.726616433374799, -3.552685892017083], [0.3653010148791735, 1.6736547762277736, 0.4531478751025384, -16.54229219042565, -3.440356011229119, 1.0104044032989574, -1.5155008934004035, 0.10642496061430406, -0.31316504641192483, 3.6828030284027515, -0.7489883459127186, -1.5244542545724582], [3.764701498917189, 0.4439295275324288, -2.9864503359860985, -3.9316071635513206, 5.798674529890128, -5.74883908980071, 5.398546661400034, -2.51467872126794, 10.108154232633654, -2.18382803218839, 2.5521301844943816, 3.311614056240679], [3.540372052106104, 4.504838909273797, 0.9723232714577832, -8.437301256316747, 14.998025152577217, -0.31994218366769667, -2.907161494453055, 3.893824258473095, -0.7579119727276817, 5.473585535436292, -3.2397908440984766, 15.192742537984023], [-6.248680428157617, -6.451873887564568, 1.6916836827123973, -4.655942296742202, 16.84212812043791, 5.734711342713387, 0.2955864473988734, 1.791898461633518, -3.4668510416701595, -1.358433980522392, -1.1057313703313203, 0.6888252016526282], [-0.43458701659431115, -0.0012780178353029815, -0.3084730481531892, 0.45069433382083834, 0.11685910089310178, -0.38449878977835567], [3.853866205452628, 12.037185197898191, 1.8699413530857774, 5.001790072421261, 4.513316028443307, 9.851232302101327]] #weight = [[1.2911306905979911, -0.24861004977707912, -0.3569265073483646, 6.428936726785303, -1.3066626434454807, 0.25686627368220305, 0.9109367109212936, 0.16801829318526124, -0.20947845384297986, 1.2064241958740287, 0.036856251428802896, -3.359023278463905], [0.8036278040339718, 0.08012145204557049, 0.6845458738830329, 5.665809973883479, -0.9210048722891027, 1.3932208121673026, 1.046083232807299, 0.7941648248360582, 0.9365855847155237, 1.459603497851585, -0.5332056328831426, -2.534773939928277], [0.13301078275476066, 0.3429847838792201, -1.0338159784473917, 4.850766016537791, 0.7802072613774678, 1.2836937010475253, -0.8584360890917163, 1.7672832265369043, 0.10738236989054603, 3.4517636983002387, 0.22658851691351473, -1.0683529525811006], [1.6450210175622832, -0.28557720210974497, -0.2443112896936013, 6.8747070212198045, -0.8271033896420884, 0.2800592224187591, 0.5652744631888489, 0.08792418368229415, 0.9155105124974535, 0.46138821886651926, -0.3837164120204661, -3.494842813175506], [-0.8165377903719206, 1.958062852731677, 2.000566970645578, 5.919031622286524, 0.5506236423988042, 0.5494849931384184, 1.7160531008225108, 0.5260681781001207, 2.06495028663279, -0.07306752095214097, -1.204154609328308, -4.01239045823013], [-0.6146224030404228, 0.3233086944120275, 5.3979041539672545, -4.401300546048576, -0.42678298976091805, 1.0758830778504247], [-5.977941738072086, 0.019369137899827416, -0.5522710341025945, -7.13480943116727, -4.873784872189164, -16.38430927507949]] #over break training weight = [[ 0.3662869049519842, -0.8570465997089849, -1.0415622777532179, 0.4420706041485171, 0.009019607340448946, 10.71120549250932, -12.382299178044326, 10.244684059761504, -4.7714116184482425, 10.703496354982395, -0.8400740885526794, 2.1209753284753745 ], [ 2.5366260663128686, 1.068830514524183, -2.0352964619508715, -0.4999108962144593, 20.533875500405504, -1.301731900907607, 0.3103574877473953, -0.6500134665269202, 0.5084981306498488, -0.8059254394827501, 1.31308616755389, 15.873718577684429 ], [ 0.08005904547677181, -0.007564753721625019, -0.10037179685269433, -30.286524359136706, 1.0348747725041256, -0.9129196441653706, 0.3754957498625551, -1.305163204786704, -0.30909410903499906, 1.3574890310465415, -0.2886464224612783, -5.911566724871949 ], [ 4.655481170315177, -1.2991521769114085, -4.454652256174474, 4.274677448402512, 16.502421922725226, 12.710289689086315, -9.738471684679293, 9.865851212762863, -8.873570414630043, -0.1285739247431209, -14.804016099227272, 10.638993200840254 ], [ -13.975667825847953, 13.618115550695093, 27.871087273931305, 1.7052627216183622, -16.717674225226972, 0.8131962686148689, 0.6430161349620291, -0.6832651795038519, 1.6123037795473343, 3.7701435389411695, -2.729257195826183, -2.0449519807080896 ], [ 0.6784559764050078, -0.30818410563793897, -0.12048266318505906, 0.7386778766766025, 0.18813592750492103, 0.9656707078851317 ], [ 7.248480099597683, 9.862850677133501, 18.95475459828898, 1.981941403265762, 7.509742979506548, 19.364672423856124 ]] sendData = getSendData() output = getOutput(sendData, 11, 5, 2, weight) turn, thrust = "N", "N" if output[0] >= .55: ai.turnRight(1) turn = "R" elif output[0] < .45: ai.turnLeft(1) turn = "L" ai.setTurnSpeed(abs(output[0] - .5) * 100) if output[1] > random(): ai.thrust(1) thrust = "Y" if ai.selfAlive(): print(turn + " " + str(round(output[0], 3)) + " | " + thrust + " " + str(round(output[1], 3)))
def AI_loop(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(45) turn, thrust = 0.5, 0 maxSpeed = 3 shotAngle = 9 wallClose = 12 heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackWall = ai.wallFeeler(500, tracking) trackLWall = ai.wallFeeler(500, tracking + 3) trackRWall = ai.wallFeeler(500, tracking - 3) frontWall = ai.wallFeeler(500, heading) flWall = ai.wallFeeler(500, heading + 10) frWall = ai.wallFeeler(500, heading - 10) leftWall = ai.wallFeeler(500, heading + 90) rightWall = ai.wallFeeler(500, heading - 90) trackWall = ai.wallFeeler(500, tracking) backWall = ai.wallFeeler(500, heading - 180) backLeftWall = ai.wallFeeler(500, heading - 185) backRightWall = ai.wallFeeler(500, heading - 175) speed = ai.selfSpeed() closest = min(frontWall, leftWall, rightWall, backWall, flWall, frWall) def closestWall(x): #Find the closest Wall return { frontWall: 1, leftWall: 2, rightWall: 3, backWall: 4, flWall: 5, frWall: 6, }[x] wallNum = closestWall(closest) crashWall = min( trackWall, trackLWall, trackRWall ) #The wall we are likely to crash into if we continue on our current course #Rules for turning if wallNum == 1 or wallNum == 5 or wallNum == 6: #Front Wall is Closest (Turn Away From It) ai.turnLeft(1) turn = 0 elif wallNum == 2: # Left Wall is Closest (Turn Away From It) ai.turnRight(1) turn = 1 elif wallNum == 3: #Right Wall is Closest (Turn Away From It) ai.turnLeft(1) turn = 0 else: #Back Wall is closest- turn so that we are facing directly away from it if backLeftWall < backRightWall: ai.turnRight( 1) #We need to turn right to face more directly away from it turn = 1 if backLeftWall > backRightWall: # We need to turn left to face more directly away from it ai.turnLeft(1) turn = 0 #Rules for thrusting if speed < maxSpeed and frontWall > 100: #If we are moving slowly and we won't ram into anything, accelerate ai.thrust(1) thrust = 1 elif trackWall < 250 and ( ai.angleDiff(heading, tracking) > 120 ): #If we are getting close to a wall, and we can thrust away from it, do so ai.thrust(1) thrust = 1 elif backWall < 20: #If there is a wall very close behind us, get away from it ai.thrust(1) thrust = 1
def AI_loop(): turn, thrust = .5, 0 ai.turnLeft(0) ai.turnRight(0) ai.thrust(0) ai.setTurnSpeed(64) heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackWall = ai.wallFeeler(500, tracking) trackL3 = ai.wallFeeler(500, tracking + 3) trackL10 = ai.wallFeeler(500, tracking + 10) trackR3 = ai.wallFeeler(500, tracking - 3) trackR10 = ai.wallFeeler(500, tracking - 10) frontWall = ai.wallFeeler(500, heading) frontL = ai.wallFeeler(500, heading + 15) frontR = ai.wallFeeler(500, heading - 15) leftWall = ai.wallFeeler(500, heading + 90) leftF = ai.wallFeeler(500, heading + 65) leftB = ai.wallFeeler(500, heading + 115) rightWall = ai.wallFeeler(500, heading - 90) rightF = ai.wallFeeler(500, heading - 65) rightB = ai.wallFeeler(500, heading - 115) backWall = ai.wallFeeler(500, heading - 180) backL = ai.wallFeeler(500, heading - 195) backR = ai.wallFeeler(500, heading - 165) trackHeadRelative = (tracking - heading) speed = ai.selfSpeed() def findClosestArea(x): return { frontWall: 1, frontL: 2, leftF: 3, leftWall: 4, leftB: 5, backL: 6, backWall: 7, backR: 8, rightB: 9, rightWall: 10, rightF: 11, frontR: 12 }[x] closestVal = min(frontWall, frontL, leftF, leftWall, leftB, backL, backWall, backR, rightB, rightWall, rightF, frontR) #Find the closest Wall to our ship closestWall = findClosestArea(closestVal) #The wall we are likely to crash into if we continue on our current course crashWall = min(trackWall, trackL3, trackL10, trackR3, trackR10) #Rules for turning if closestWall == 1: ai.setTurnSpeed(64) ai.turnLeft(1) turn = 0 elif closestWall == 2: ai.setTurnSpeed(64) ai.turnRight(1) turn = 1 elif closestWall == 3: ai.setTurnSpeed(52) ai.turnRight(1) turn = .9 elif closestWall == 4: ai.setTurnSpeed(40) ai.turnRight(1) turn = .8 elif closestWall == 5: ai.setTurnSpeed(28) ai.turnRight(1) turn = .7 elif closestWall == 6: ai.setTurnSpeed(16) ai.turnRight(1) turn = .6 elif closestWall == 7: pass elif closestWall == 8: ai.setTurnSpeed(16) ai.turnLeft(1) turn = .4 elif closestWall == 9: ai.setTurnSpeed(28) ai.turnLeft(1) turn = .3 elif closestWall == 10: ai.setTurnSpeed(40) ai.turnLeft(1) turn = .2 elif closestWall == 11: ai.setTurnSpeed(52) ai.turnLeft(1) turn = .1 elif closestWall == 12: ai.setTurnSpeed(64) ai.turnLeft(1) turn = 0 #Rules for thrusting #if we are going slow and there isn't a wall in front of us if min(frontWall, frontL, frontR) > 100 and speed < 4: ai.thrust(1) thrust = 1 #if we are heading toward a wall and we are not facing it elif crashWall < 150 and (ai.angleDiff(heading, tracking) > 90): ai.thrust(1) thrust = 1 #If there is a wall very close behind us, get away from it elif backWall < 20 or backL < 20 or backR < 20: ai.thrust(1) thrust = 1 doBackPropigation = False if ai.selfAlive() and doBackPropigation: #adjust the the learning NN infile = open("Sem2W_2.txt", "r") weight = eval(infile.read()) infile.close() sendData = getSendData(turn, thrust) weight = adjustNN(sendData, 17, 7, 2, weight) outfile = open("Sem2W_2.txt", "w") outfile.write(str(weight)) outfile.close()
def dummyLoop(): global maxSpeed, shotAngle, wallClose, dead, previousScore global turnedLeft, turnedRight, thrusted, shot #Release keys DataMinerBD.tthrustDummy(0) DataMinerBD.tturnLeftDummy(0) DataMinerBD.tturnRightDummy(0) ai.setTurnSpeed(45) #Set variables""" heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackWall = ai.wallFeeler(500, tracking) trackLWall = ai.wallFeeler(500, tracking + 3) trackRWall = ai.wallFeeler(500, tracking - 3) frontWall = ai.wallFeeler(500, heading) flWall = ai.wallFeeler(500, heading + 10) frWall = ai.wallFeeler(500, heading - 10) leftWall = ai.wallFeeler(500, heading + 90) llWall = ai.wallFeeler(500, heading + 100) rlWall = ai.wallFeeler(500, heading + 80) rightWall = ai.wallFeeler(500, heading - 90) lrWall = ai.wallFeeler(500, heading - 80) rrWall = ai.wallFeeler(500, heading - 100) trackWall = ai.wallFeeler(500, tracking) backWall = ai.wallFeeler(500, heading - 180) backLeftWall = ai.wallFeeler(500, heading - 190) backRightWall = ai.wallFeeler(500, heading - 170) speed = ai.selfSpeed() closest = min(frontWall, leftWall, rightWall, backWall, flWall, frWall) def closestWall(x): #Find the closest Wall return { frontWall: 1, leftWall: 2, rightWall: 3, backWall: 4, flWall: 5, frWall: 6, }[x] wallNum = closestWall(closest) #Code for finding the angle to the closest ship targetX, targetY = ai.screenEnemyX(0), ai.screenEnemyY(0) #baseString = "["+str(flWall/500)+","+str(frontWall/500)+","+str(frWall/500) + "," + str(backLeftWall/500) + "," + str(backWall/500) + "," + str(backRightWall/500) + ","+str(leftWall/500)+","+str(rightWall/500)+","+str(trackLWall/500) + "," + str(trackWall/500) + ","+str(trackRWall/500) + "," + str(speed/10) calcDir = -1 if targetX - ai.selfX() != 0: calcDir = (math.degrees( math.atan2((targetY - ai.selfY()), (targetX - ai.selfX()))) + 360) % 360 crashWall = min( trackWall, trackLWall, trackRWall ) #The wall we are likely to crash into if we continue on our current course #Rules for turning if crashWall > wallClose * speed and closest > 25 and targetX != -1: #If we are far enough away from a predicted crash and no closer than 25 pixels to a wall we can try and aim and kill them diff = (calcDir - heading) #if ai.shotAlert(0) > -1 and ai.shotAlert(0) < 35: #If we are about to get shot # tturnRight(1) #Screw aiming and turn right and thrust # tthrust(1) #This is arguably a horrible strategy because our sideways profile is much larger, but it's required for the grade if diff >= 0: if diff >= 180: DataMinerBD.tturnRightDummy( 1) #If the target is to our right- turn right else: DataMinerBD.tturnLeftDummy( 1) #If the target is to our left - turn left else: if diff > -180: DataMinerBD.tturnRightDummy( 1) #If the target is to our right - turn right else: DataMinerBD.tturnLeftDummy( 1) #If the target is to our left - turn left else: #Rules for avoiding death # if crashWall/ai.selfSpeed() > ai.closestShot() : if wallNum == 1 or wallNum == 5 or wallNum == 6: #Front Wall is Closest (Turn Away From It) DataMinerBD.tturnLeftDummy(1) elif wallNum == 2: # Left Wall is Closest (Turn Away From It) DataMinerBD.tturnRightDummy(1) elif wallNum == 3: #Right Wall is Closest (Turn Away From It) DataMinerBD.tturnLeftDummy(1) else: #Back Wall is closest- turn so that we are facing directly away from it if backLeftWall < backRightWall: DataMinerBD.tturnRightDummy( 1 ) #We need to turn right to face more directly away from it if backLeftWall > backRightWall: # We need to turn left to face more directly away from it DataMinerBD.tturnLeftDummy(1) #Rules for thrusting if speed < maxSpeed and frontWall > 100: #If we are moving slowly and we won't ram into anything, accelerate DataMinerBD.tthrustDummy(1) elif trackWall < 200 and ( ai.angleDiff(heading, tracking) > 120 ): #If we are getting close to a wall, and we can thrust away from it, do so DataMinerBD.tthrustDummy(1) elif backWall < 20: #If there is a wall very close behind us, get away from it DataMinerBD.tthrustDummy(1) if abs( calcDir - heading ) < shotAngle and calcDir != -1: #If we are close to the current proper trajectory for a shot then fire DataMinerBD.tshootDummy() previousScore = ai.selfScore()
def AI_loop(): turn, thrust = .5, 0 ai.turnLeft(0) ai.turnRight(0) ai.thrust(0) ai.setTurnSpeed(64) heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackWall = ai.wallFeeler(500, tracking) frontL = ai.wallFeeler(500, heading + 10) frontR = ai.wallFeeler(500, heading - 10) leftF = ai.wallFeeler(500, heading + 70) leftB = ai.wallFeeler(500, heading + 110) rightF = ai.wallFeeler(500, heading - 70) rightB = ai.wallFeeler(500, heading - 110) backL = ai.wallFeeler(500, heading - 200) backR = ai.wallFeeler(500, heading - 160) trackHeadRelative = (tracking - heading) speed = ai.selfSpeed() def findClosestArea(x): return { frontL: 1, leftF: 2, leftB: 3, backL: 4, backR: 5, rightF: 6, rightB: 7, frontR: 8 }[x] closestVal = min(frontL, leftF, leftB, backL, backR, rightF, rightB, frontR) #Find the closest Wall to our ship closestWall = findClosestArea(closestVal) #Rules for turning if closestWall == 1: ai.setTurnSpeed(64) ai.turnRight(1) turn = 1 elif closestWall == 2: ai.setTurnSpeed(46) ai.turnRight(1) turn = .9 elif closestWall == 3: ai.setTurnSpeed(28) ai.turnRight(1) turn = .8 elif closestWall == 4: ai.setTurnSpeed(10) ai.turnRight(1) turn = .6 elif closestWall == 5: ai.setTurnSpeed(10) ai.turnLeft(1) turn = .4 elif closestWall == 6: ai.setTurnSpeed(28) ai.turnLeft(1) turn = .2 elif closestWall == 7: ai.setTurnSpeed(26) ai.turnLeft(1) turn = .1 elif closestWall == 8: ai.setTurnSpeed(64) ai.turnLeft(1) turn = 0 #Rules for thrusting #if we are going slow and there isn't a wall in front of us if min(frontL, frontR) > 100 and speed < 3: ai.thrust(1) thrust = 1 #if we are heading toward a wall and we are not facing it elif trackWall < 150 and (ai.angleDiff(heading, tracking) > 90): ai.thrust(1) thrust = 1 #If there is a wall very close behind us, get away from it elif backL < 20 or backR < 20: ai.thrust(1) thrust = 1 doBackPropigation = True if ai.selfAlive() and doBackPropigation: #adjust the the learning NN infile = open("Sem2W_1.txt", "r") weight = eval(infile.read()) infile.close() sendData = getSendData(turn, thrust) weight = adjustNN(sendData, 12, 5, 2, weight) outfile = open("Sem2W_1.txt", "w") outfile.write(str(weight)) outfile.close()
def AI_loop(): #Inserted Code if ai.selfAlive(): DataMinerBD.updateInputs() DataMinerBD.updateOutputs() DataMinerBD.savePair() print(DataMinerBD.length()) if DataMinerBD.length() > 10000: DataMinerBD.writeData() print("Finished") ai.quitAI() global lastTurn #Release keys DataMinerBD.tthrust(0) DataMinerBD.tturnLeft(0) DataMinerBD.tturnRight(0) ai.setTurnSpeed(45) #Set variables""" heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackWall = ai.wallFeeler(500, tracking) trackLWall = ai.wallFeeler(500, tracking+3) trackRWall = ai.wallFeeler(500, tracking - 3) frontWall = ai.wallFeeler(500,heading) flWall = ai.wallFeeler(500, heading + 10) frWall = ai.wallFeeler(500, heading - 10) leftWall = ai.wallFeeler(500,heading+90) rightWall = ai.wallFeeler(500,heading-90) trackWall = ai.wallFeeler(500,tracking) backWall = ai.wallFeeler(500, heading - 180) backLeftWall = ai.wallFeeler(500, heading - 185) backRightWall = ai.wallFeeler(500, heading - 175) speed = ai.selfSpeed() closest = min(frontWall, leftWall, rightWall, backWall) def closestWall(x): #Find the closest Wall return { frontWall : 1, leftWall : 2, rightWall : 3, backWall : 4, flWall : 5, frWall : 6, }[x] wallNum = closestWall(closest) #Code for finding the angle to the closest ship target = ai.closestShipId() targetX, targetY = ai.screenEnemyX(0), ai.screenEnemyY(0) calcDir = 0 if targetX- ai.selfX() != 0: calcDir = (math.degrees(math.atan2((targetY - ai.selfY()), (targetX- ai.selfX()))) + 360)%360 targetDir = calcDir crashWall = min(trackWall, trackLWall, trackRWall) #The wall we are likely to crash into if we continue on our current course #Rules for turning if crashWall > 25*speed and closest > 30 and targetX != -1: #If we are far enough away from a predicted crash and no closer than 25 pixels to a wall, and there isn't a wall between us and the closest enemy #print("Aiming", targetDir, " Current", heading) diff = (calcDir - heading) if ai.shotAlert(0) > -1 and ai.shotAlert(0) < 35: DataMinerBD.tturnRight(1) DataMinerBD.tthrust(1) elif diff >= 0: if diff >= 180: a = 0 DataMinerBD.tturnRight(1) #If the target is to our right- turn right elif diff != 0 : a = 0 DataMinerBD.tturnLeft(1) #If the target is to our left - turn left else : if diff > -180: a = 0 DataMinerBD.tturnRight(1) #If the target is to our right - turn right else : a = 0 DataMinerBD.tturnLeft(1) #If the target is to our left - turn left else : #Rules for avoiding death # if crashWall/ai.selfSpeed() > ai.closestShot() : #We find a target heading using our current trajectory and the closest wall then turn in it's direction targetHeading = heading print(heading) if wallNum == 1or wallNum == 6 or wallNum == 5: #Front Wall is Closest if lastTurn == 1: targetHeading += 270 targetHeading = (targetHeading)%360 else : targetHeading +=90 targetHeading = targetHeading%360 print("front") elif wallNum == 2 : # Left Wall is Closest targetHeading += 270 targetHeading = (targetHeading)%360 lastTurn = 1 print("leftwall") elif wallNum == 3 : targetHeading = targetHeading + 90 targetHeading = (targetHeading)%360 lastTurn = 2 print("rightWall") else : if backLeftWall < backRightWall: lastTurn = 2 targetHeading += 5 targetHeading = (targetHeading)%360 if backLeftWall > backRightWall: lastTurn = 1 targetHeading -= 5 targetHeading = (targetHeading)%360 speedConcern = ai.selfSpeed() - 4 if speedConcern < 0: speedConcern = 0 elif speedConcern > 5: speedConcern = 5 #targetHeading = (targetHeading*(1-(speedConcern/5))) + (((tracking+170)%360)*(speedConcern/5)) if speedConcern > 2: targetHeading = (tracking + 180)%360 diff = (targetHeading - heading) print("targetHEading : ", targetHeading, " heading : ", heading) if diff >= 0: if diff >= 180: DataMinerBD.tturnRight(1) #If the targetHEading is to our right- turn right print("right") elif diff != 0 : DataMinerBD.tturnLeft(1) #If the targeHeadingt is to our left - turn left print("left") else : if diff > -180: print("right") DataMinerBD.tturnRight(1) #If the targetHeading is to our right - turn right #print("right") else : print("left") DataMinerBD.tturnLeft(1) #If the targetHeading is to our left - turn left #print("nice") #Rules for thrusting if speed < 5 and frontWall > 200: #If we are moving slowly and we won't ram into anything, accelerate DataMinerBD.tthrust(1) elif crashWall < 25*speed and (abs(tracking - heading) > 120): #If we are getting close to a wall, and we can thrust away from it, do so DataMinerBD.tthrust(1) elif backWall < 30: #If there is a wall very close behind us, get away from it DataMinerBD.tthrust(1) if abs(calcDir - heading) < 15 : #If we are close to the current proper trajectory for a shot then fire DataMinerBD.tshoot()
def AI_loop(): turn, thrust = .5, 0 ai.turnLeft(0) ai.turnRight(0) ai.thrust(0) ai.setTurnSpeed(64) heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackWall = ai.wallFeeler(500, tracking) frontL = ai.wallFeeler(500, heading + 10) frontR = ai.wallFeeler(500, heading - 10) leftF = ai.wallFeeler(500, heading + 70) leftB = ai.wallFeeler(500, heading + 110) rightF = ai.wallFeeler(500, heading - 70) rightB = ai.wallFeeler(500, heading - 110) backL = ai.wallFeeler(500, heading - 190) backR = ai.wallFeeler(500, heading - 170) speed = ai.selfSpeed() def findClosestArea(x): return { frontL: 1, leftF: 2, leftB: 3, backL: 4, backR: 5, rightF: 6, rightB: 7, frontR: 8 }[x] closestVal = min(frontL, leftF, leftB, backL, backR, rightF, rightB, frontR) #Find the closest Wall to our ship closestWall = findClosestArea(closestVal) #Rules for turning #if we are heading for a wall, turn away from it if trackWall < 100: #round(abs(ai.angleDiff(heading, tracking))/3) ai.setTurnSpeed(15 + round(abs(ai.angleDiff(heading, tracking)) / 4)) if ai.angleDiff(heading, tracking) > 0: ai.turnRight(1) turn = .9 else: ai.turnLeft(1) turn = .1 #otherwise turn away from the closest wall elif closestWall == 1: ai.setTurnSpeed(64) ai.turnRight(1) turn = 1 elif closestWall == 2: ai.setTurnSpeed(46) ai.turnRight(1) turn = .9 elif closestWall == 3: ai.setTurnSpeed(28) ai.turnRight(1) turn = .8 elif closestWall == 4: ai.setTurnSpeed(10) ai.turnRight(1) turn = .6 elif closestWall == 5: ai.setTurnSpeed(10) ai.turnLeft(1) turn = .4 elif closestWall == 6: ai.setTurnSpeed(28) ai.turnLeft(1) turn = .2 elif closestWall == 7: ai.setTurnSpeed(26) ai.turnLeft(1) turn = .1 elif closestWall == 8: ai.setTurnSpeed(64) ai.turnLeft(1) turn = 0 #if we are going too fast and are not in danger turn around # if speed > 2.5 and closestVal > 100: # ai.setTurnSpeed(64) # if ai.angleDiff(heading, tracking) > 0: # ai.turnRight(1) # turn = 1 # #print("R",random()) # else: # ai.turnLeft(1) # turn = 0 #print("L",random()) #Rules for thrusting #if we are going slow and there isn't a wall in front of us if min(frontL, frontR) > 100 and speed < 2.5: ai.thrust(1) thrust = 1 #if we are going too fast and are facing away from the direction we are heading elif abs(ai.angleDiff(heading, tracking)) > 135 and speed > 2.5: ai.thrust(1) thrust = 1 #if we are heading toward a wall and we are not facing it elif trackWall < 150 and (abs(ai.angleDiff(heading, tracking)) > 120): ai.thrust(1) thrust = 1 #If there is a wall very close behind us, get away from it elif backL < 25 or backR < 25: ai.thrust(1) thrust = 1 doBackPropigation = False if ai.selfAlive() and doBackPropigation: #adjust the the learning NN infile = open("Sem2W_1.txt", "r") weight = eval(infile.read()) infile.close() sendData = getSendData(turn, thrust) weight = adjustNN(sendData, 12, 5, 2, weight) outfile = open("Sem2W_1.txt", "w") outfile.write(str(weight)) outfile.close()
def AI_loop(self): # print("AI_LOOP") if ai.selfAlive() == 0: print("selfAlive is 0") # if ai.selfAlive() == 0 and time2quit: outputFile = open("output.txt", "w") outputFile.write(str(self.counter)) outputFile.close() # ai.quitAI() # print(countFrames) # Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(55) turnSpeedMin = 15 turnSpeedMax = 64 # Heuristics #frontFeelerOffset = 35 ffo = self.frontFeelerOffset rfo = self.rearFeelerOffset perpFeelerOffset = 90 #rearFeelerOffset = 135 # speedLimit = 5 lowSpeedLimit = 2 targetingAccuracy = 4 # 1/2 tolerance in deg for aiming accuracy shotIsDangerous = 130 # Acquire information heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) # Wall feeling feelers = [] frontWall = ai.wallFeeler(750, heading) leftWall = ai.wallFeeler(500, heading + perpFeelerOffset) rightWall = ai.wallFeeler(500, heading - perpFeelerOffset) trackWall = ai.wallFeeler(750, tracking) rearWall = ai.wallFeeler(250, heading - 180) backLeftWall = ai.wallFeeler(500, heading + round(rfo)) backRightWall = ai.wallFeeler(500, heading - round(rfo)) frontLeftWall = ai.wallFeeler(500, heading + round(ffo)) frontRightWall = ai.wallFeeler(500, heading - round(ffo)) feelers.append(frontWall) feelers.append(leftWall) feelers.append(rightWall) feelers.append(trackWall) feelers.append(rearWall) feelers.append(backLeftWall) feelers.append(backRightWall) feelers.append(frontLeftWall) feelers.append(frontRightWall) if min(feelers) < self.veryNearLimit: self.speedLimit = lowSpeedLimit # Movement controls # Compute angles to the nearest things m = self.angleToPointDeg((ai.selfX(), ai.selfY()), (ai.shotX(0), ai.shotY(0))) n = self.angleToPointDeg((ai.selfX(), ai.selfY()), (ai.shotX(0), ai.shotY(0))) # Sets turn speed and degree to the enemy if ai.screenEnemyX(0) >= 0: enemyDeg = self.angleToPointDeg( (ai.selfX(), ai.selfY()), (ai.screenEnemyX(0), ai.screenEnemyY(0))) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, turnSpeedMin, turnSpeedMax)) else: enemyDeg = self.angleToPointDeg( (ai.selfRadarX(), ai.selfRadarY()), (ai.closestRadarX(), ai.closestRadarY())) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, turnSpeedMin, turnSpeedMax)) # Turn towards unoccluded enemies while in open space if ai.aimdir(0) >= 0 and self.headingDiff( heading, ai.aimdir(0)) > 0 and not self.enemyBehindWall(0): ai.turnRight(1) elif ai.aimdir(0) >= 0 and self.headingDiff( heading, ai.aimdir(0)) < 0 and not self.enemyBehindWall(0): ai.turnLeft(1) # Turn away from nearby walls elif min(feelers) < ai.enemyDistance( 0 ) and trackWall < self.nearLimit and leftWall < rightWall: #DONE ai.turnRight(1) elif min(feelers) < ai.enemyDistance( 0 ) and trackWall < self.nearLimit and rightWall < leftWall: #DONE ai.turnLeft(1) elif min(feelers) < ai.enemyDistance( 0 ) and backLeftWall < self.nearLimit and rightWall > self.nearLimit: ai.turnRight(1) elif min(feelers) < ai.enemyDistance( 0 ) and backRightWall < self.nearLimit and leftWall > self.nearLimit: ai.turnLeft(1) elif min(feelers) < ai.enemyDistance( 0) and frontRightWall < self.nearLimit: ai.turnLeft(1) elif min(feelers) < ai.enemyDistance( 0) and frontLeftWall < self.nearLimit: ai.turnRight(1) # TODO: NEED RULES FOR WHEN ENEMY IS OCCLUDED elif self.enemyBehindWall and enemyDeg < 0: ai.turnRight(1) elif self.enemyBehindWall and enemyDeg >= 0: ai.turnLeft(1) # Turn away from shots elif m > 0: ai.turnRight(1) elif m < 0: ai.turnLeft(1) # THRUST (includes fuzzy controller) # Power levels power1 = 55 power2 = 45 power3 = 55 power4 = 36 power5 = 36 power6 = 28 power7 = 24 power8 = 30 mfS = self.mfSpeed(ai.selfSpeed()) mfD = self.mfDanger(ai.shotAlert(0)) # Aggregation # if S is high and D is moderate or high: p1 = max(mfS[2], min(mfD[1], mfD[2])) # if S is moderate and D is moderate: p2 = max(mfS[1], mfD[1]) # if S is low and D is high: p3 = max(mfS[0], mfD[2]) # if S is moderate and D is moderate: p4 = max(mfS[1], mfD[1]) # if S is low and D is moderate: p5 = max(mfS[0], mfD[1]) # if S is high and D is low: p6 = max(mfS[2], mfD[0]) # if S is moderate and D is low: p7 = max(mfS[1], mfD[0]) # if S is low and D is low: p8 = max(mfS[0], mfD[0]) consequents = [ power1, power2, power3, power4, power5, power6, power7, power8 ] memberships = [p1, p2, p3, p4, p5, p6, p7, p8] # Defuzzification ai.setPower(self.crispify(memberships, consequents)) # Further thrusting rules if ai.shotAlert(0) < 130 and ai.shotAlert(0) != -1 and ai.wallBetween( ai.selfX(), ai.selfY(), ai.shotX(0), ai.shotY(0)) == -1: ai.thrust(1) elif ai.selfSpeed() <= self.speedLimit: ai.thrust(1) elif trackWall < self.nearLimit and self.angleDiff(heading, tracking) > 75: ai.thrust(1) elif rearWall < self.nearLimit and self.angleDiff(heading, tracking) > 90: ai.thrust(1) # FIRE # Restrict firing to reasonably accurate attempts if self.headingDiff(heading, ai.aimdir( 0)) < targetingAccuracy and not self.enemyBehindWall(0): ai.fireShot() self.counter += 1
def AI_loop(self): # print("AI_LOOP") if ai.selfAlive() == 0: outputFile = open("fitness.txt", "a") # outputFile.write(str((self.totalDists/self.counter))+"\t") outputFile.write(str(int((self.fitness**1.2))) + "\t") [ print(str("%.5f" % g) + "\t", end="", file=outputFile) for g in self.chromosome ] print("\n", end="", file=outputFile) outputFile.close() # Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(55) # Heuristics frontFeelerOffset = 45 perpFeelerOffset = 90 rearFeelerOffset = 135 # turnSpeedMin = 15 # learn range: 4 - 24 turnSpeedMax = 55 speedLimit = 5 # learn range: 2-6 lowSpeedLimit = 2 targetingAccuracy = 4 # 1/2 tolerance in deg for aiming accuracy shotIsDangerous = 130 # Acquire information heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) ###=== ENEMY FEELERS ===### # gets angle to enemy enemyDeg = self.angleToPointDeg( (ai.selfX(), ai.selfY()), (ai.screenEnemyX(0), ai.screenEnemyY(0))) enemyWallDistances = [] # maxAngleOffset = 90 # learn range: 30 - 120 # resolution = 5 # learn range: 2 - 10 distAngleTuples = [] # creates tuples of degrees and wallFeelers for m in (0, self.maxAngleOffset, self.resolution): distAngleTuples.append( (enemyDeg - m, ai.wallFeeler(500, int(enemyDeg - m)))) distAngleTuples.append( (enemyDeg + m, ai.wallFeeler(500, int(enemyDeg + m)))) # gets furthest feeler maxFeelerAngle = max(distAngleTuples, key=self.returnSecond) angleToOpenSpace = self.headingDiff(ai.selfHeadingDeg(), maxFeelerAngle[0]) ###=== WALL FEELERS ===### frontWall = ai.wallFeeler( self.genericFeelerDist, heading) # wall feeler for wall directly ahead leftFrontWall = ai.wallFeeler( self.genericFeelerDist, heading + frontFeelerOffset) # wall feeler for wall 45 degrees to the left rightFrontWall = ai.wallFeeler( self.genericFeelerDist, heading - frontFeelerOffset) # wall feeler for wall 45 degrees to the right leftWall = ai.wallFeeler( self.genericFeelerDist, heading + perpFeelerOffset) # wall feeler for wall 90 degrees to the left rightWall = ai.wallFeeler( self.genericFeelerDist, heading - perpFeelerOffset) # wall feeler for wall 90 degrees to the right backWall = ai.wallFeeler(self.genericFeelerDist, heading - 180) # wall feeler for wall straight back leftBackWall = ai.wallFeeler( self.genericFeelerDist, heading + rearFeelerOffset) # wall feeler for wall 135 degrees to the left rightBackWall = ai.wallFeeler( self.genericFeelerDist, heading - rearFeelerOffset) # wall feeler for wall 135 degrees to the right trackWall = ai.wallFeeler( self.genericFeelerDist, tracking) # wall in front of where ship is moving # Keep track of all the feeler distances feelers = [ frontWall, leftFrontWall, rightFrontWall, leftWall, rightWall, backWall, leftBackWall, rightBackWall, trackWall ] # Aim assist leftDir = (heading + 90) % 360 # angle 90 degrees to the left of current heading rightDir = (heading - 90 ) % 360 # angle 90 degrees to the right of current heading aimer = ai.aimdir( 0 ) # direction that the ship needs to turn to in order to face the enemy in degrees shot = ai.shotAlert( 0 ) # returns a danger rating of a shot, the smaller the number the more likely the shot is to hit the ship enemyX = ai.screenEnemyX(0) # returns the closest enemy's x-coord enemyY = ai.screenEnemyY(0) # returns the closest enemy's y-coord selfX = ai.selfX() # returns the ship's x-coord selfY = ai.selfY() # returns the ship's x-coord # Fuzzy variable declaration trackRisk = riskEval(trackWall, ai.selfSpeed()) #risk of running into trackWall frontRisk = riskEval(frontWall, ai.selfSpeed()) #risk of running into frontWall leftRisk = riskEval(leftWall, ai.selfSpeed()) #risk of running into leftWall rightRisk = riskEval(rightWall, ai.selfSpeed()) #risk of running into rightWall LFRisk = riskEval(leftFrontWall, ai.selfSpeed()) #risk of running into leftFrontWall RFRisk = riskEval(rightFrontWall, ai.selfSpeed()) #risk of running into rightFrontWall LBRisk = riskEval(leftBackWall, ai.selfSpeed()) #risk of running into leftBackWall RBRisk = riskEval(rightBackWall, ai.selfSpeed()) #risk of running into rightBackWall backRisk = riskEval(backWall, ai.selfSpeed()) #risk of running into backWall # Compress some wall feelers sTrack = self.squisher(trackWall) sLeft = self.squisher(leftFrontWall) sRight = self.squisher(rightFrontWall) sLeftStraight = self.squisher(leftWall) sRightStraight = self.squisher(rightWall) # output from neural network that tells how much to turn and which direction turn = self.trainedNeuralNetwork(sTrack, sLeft, sRight, sLeftStraight, sRightStraight) ###=== THRUST POWER ADJUSTMENT ===# # Power levels mfS = self.mfSpeed(ai.selfSpeed()) mfD = self.mfDanger(ai.shotAlert(0)) # if S is high and D is moderate or high: p1 = max(mfS[2], min(mfD[1], mfD[2])) # if S is moderate and D is moderate: p2 = max(mfS[1], mfD[1]) # if S is low and D is high: p3 = max(mfS[0], mfD[2]) # if S is moderate and D is moderate: p4 = max(mfS[1], mfD[1]) # if S is low and D is moderate: p5 = max(mfS[0], mfD[1]) # if S is high and D is low: p6 = max(mfS[2], mfD[0]) # if S is moderate and D is low: p7 = max(mfS[1], mfD[0]) # if S is low and D is low: p8 = max(mfS[0], mfD[0]) consequents = [55, 45, 55, 36, 36, 28, 24, 30] memberships = [p1, p2, p3, p4, p5, p6, p7, p8] ai.setPower(self.crispify(memberships, consequents)) if ai.enemyDistance(0) > self.lastDist and ai.enemyDistance( 0) < self.enemyClose: ai.thrust(1) elif ai.selfSpeed( ) <= 3 and frontWall >= 200: # if speed is slow and front wall is far away, thrust ai.thrust(1) elif trackWall < 60 and frontWall >= 200: # if the track wall is close, thrust ai.thrust(1) elif backWall < 20: # if the back wall is close, thrust ai.thrust(1) ###=== TURNING RULES ===### # Escape shots if shot > 0 and shot < 70: # if a shot is closeby, turn and thrust to avoid if self.angleDif(rightDir, ai.shotX(0)) < self.angleDif( leftDir, ai.shotX(0) ) or self.angleDif(rightDir, ai.shotY(0)) < self.angleDif( leftDir, ai.shotY(0) ): # if shot is coming from the right, turn away and thrust # print("Turning: avoiding shot")#debug ai.turnLeft(1) ai.thrust(1) elif self.angleDif(leftDir, ai.shotX(0)) < self.angleDif( rightDir, ai.shotX(0) ) or self.angleDif(leftDir, ai.shotY(0)) < self.angleDif( rightDir, ai.shotY(0) ): # if shot is coming from the left, turn away and shoot ------> change this shot is just a number # print("Turning: avoiding shot")#debug ai.turnRight(1) ai.thrust(1) # Turn towards unoccluded enemy elif aimer >= 0 and self.angleDif(rightDir, aimer) < self.angleDif( leftDir, aimer) and not self.enemyBehindWall( 0): # if an enemy to the right, turn and shoot it if ai.screenEnemyX(0) >= 0: enemyDeg = self.angleToPointDeg( (ai.selfX(), ai.selfY()), (ai.screenEnemyX(0), ai.screenEnemyY(0))) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, self.turnSpeedMin, turnSpeedMax)) else: enemyDeg = self.angleToPointDeg( (ai.selfRadarX(), ai.selfRadarY()), (ai.closestRadarX(), ai.closestRadarY())) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, self.turnSpeedMin, turnSpeedMax)) # print("Turning: aiming right")#debug ai.turnRight(1) elif aimer >= 0 and self.angleDif(leftDir, aimer) < self.angleDif( rightDir, aimer) and not self.enemyBehindWall( 0): # if an enemy to the left, turn and shoot it if ai.screenEnemyX(0) >= 0: enemyDeg = self.angleToPointDeg( (ai.selfX(), ai.selfY()), (ai.screenEnemyX(0), ai.screenEnemyY(0))) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, self.turnSpeedMin, turnSpeedMax)) else: enemyDeg = self.angleToPointDeg( (ai.selfRadarX(), ai.selfRadarY()), (ai.closestRadarX(), ai.closestRadarY())) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, self.turnSpeedMin, turnSpeedMax)) # print("Turning: aiming left")#debug ai.turnLeft(1) #fuzzy avoid walls ahead elif leftRisk > rightRisk and trackRisk > 0.5: # and min(feelers) < self.nearLimit: #if the left wall and track walls are close, turn right #if enemyX >=0 and enemyY >= 0 and ai.wallBetween(selfX, selfY, enemyX, enemyY) == -1: ai.turnRight(1) # print("Turning: fuzzy right")#debug elif rightRisk > leftRisk and trackRisk > 0.5: # and min(feelers) < self.nearLimit: #if the right wall and track walls are close, turn left # if enemyX >=0 and enemyY >= 0 and ai.wallBetween(selfX, selfY, enemyX, enemyY) == -1: ai.turnLeft(1) # print("Turning: fuzzy left")#debug # Turn to open space nearest the angle to the enemy elif self.enemyBehindWall(0) and min(feelers) > self.nearLimit: if angleToOpenSpace < 0: # print("Turning: open space left")#debug ai.turnLeft(1) elif angleToOpenSpace > 0: # print("Turning: open space right")#debug ai.turnRight(1) # if neural net value is not between 0.48 and 0.52 then we have to turn right or left elif not (turn >= 0.43 and turn <= 0.57): if turn < 0.43: # turn right if value is below 0.43 # print("Turning: neural net right")#debug ai.turnRight(1) elif turn > 0.57: # turn left if value is below 0.57 # print("Turning: neural net left")#debug ai.turnLeft(1) ###=== FIRING RULES ===### # Restrict firing to reasonably accurate attempts: # accurate range, enemy not behind wall and enemy close enough if self.headingDiff( heading, ai.aimdir(0)) < targetingAccuracy and not self.enemyBehindWall( 0) and ai.enemyDistance(0) < self.enemyFireDist: ai.fireShot() # print("Shot Fired")#debug # print("Firing Dist: ", self.enemyFireDist)#debug self.counter += 1 ###=== How did we die? and other Fitness Calculations ===### # Fitness function information self.totalDists += ai.enemyDistance(0) if ai.enemyDistance(0) > 0: self.currentDist = ai.enemyDistance(0) if self.currentDist < self.lastDist: self.fitness += 1 self.lastDist = self.currentDist self.fitness += 1 alive = ai.selfAlive() message = ai.scanGameMsg(1) # print(message)#debug if alive == 0: self.framesDead += 1 # print(self.framesDead, message)#debug if self.framesDead == 2: # print("dead now")#debug # Ran into wall if message.find("Beal-Morneault") != -1 and message.find( "wall") != -1: print("End of match: wall collision.") #debug self.fitness -= self.wallPenalty # Crashed into player elif message.find("crashed.") != -1: print("End of match: player collision.") #debug self.fitness -= self.crashPenalty # Killed by bullet elif message.find("Beal-Morneault was") != -1: print("End of match: killed by opponent.") #debug self.fitness -= self.killedPenalty # Killed the opponent elif message.find("by a shot from Beal-Morneault") != -1: print("End of match: killed the opponent!") #debug self.fitness += self.killerBonus else: print("End of match: enemy died.") self.fitness += (ai.selfScore() - ai.enemyScoreId(0) ) * self.scoreDiffBonusFactor ai.quitAI() else: self.framesDead = 0
def AI_loop(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(45) turn, thrust, shoot = 0.5, 0, 0 maxSpeed = 3 shotAngle = 9 wallClose = 12 #Set variables""" heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackWall = ai.wallFeeler(500, tracking) trackLWall = ai.wallFeeler(500, tracking+3) trackRWall = ai.wallFeeler(500, tracking - 3) frontWall = ai.wallFeeler(500,heading) flWall = ai.wallFeeler(500, heading + 10) frWall = ai.wallFeeler(500, heading - 10) leftWall = ai.wallFeeler(500,heading+90) rightWall = ai.wallFeeler(500,heading-90) trackWall = ai.wallFeeler(500,tracking) backWall = ai.wallFeeler(500, heading - 180) backLeftWall = ai.wallFeeler(500, heading - 185) backRightWall = ai.wallFeeler(500, heading - 175) speed = ai.selfSpeed() closest = min(frontWall, leftWall, rightWall, backWall, flWall, frWall) def closestWall(x): #Find the closest Wall return { frontWall : 1, leftWall : 2, rightWall : 3, backWall : 4, flWall : 5, frWall : 6, }[x] wallNum = closestWall(closest) #Code for finding the angle to the closest ship targetX, targetY = ai.screenEnemyX(0), ai.screenEnemyY(0) calcDir = 0 if targetX- ai.selfX() != 0: calcDir = (math.degrees(math.atan2((targetY - ai.selfY()), (targetX- ai.selfX()))) + 360)%360 crashWall = min(trackWall, trackLWall, trackRWall) #The wall we are likely to crash into if we continue on our current course #Rules for turning if crashWall > wallClose*speed and closest > 25 and targetX != -1: #If we are far enough away from a predicted crash and no closer than 25 pixels to a wall we can try and aim and kill them diff = (calcDir - heading) if ai.shotAlert(0) > -1 and ai.shotAlert(0) < 35: #If we are about to get shot ai.turnRight(1) #Screw aiming and turn right and thrust ai.thrust(1) thrust = 1 #This is arguably a horrible strategy because our sideways profile is much larger, but it's required for the grade elif diff >= 0: if diff >= 180: ai.turnRight(1) #If the target is to our right- turn right turn = 1 else : ai.turnLeft(1) #If the target is to our left - turn left turn = 0 else : if diff > -180: ai.turnRight(1) #If the target is to our right - turn right turn = 1 else : ai.turnLeft(1) #If the target is to our left - turn left turn = 0 #Rules for avoiding death else : # if crashWall/ai.selfSpeed() > ai.closestShot() : if wallNum == 1 or wallNum == 5 or wallNum == 6: #Front Wall is Closest (Turn Away From It) ai.turnLeft(1) turn = 0 elif wallNum == 2 : # Left Wall is Closest (Turn Away From It) ai.turnRight(1) turn = 1 elif wallNum == 3 : #Right Wall is Closest (Turn Away From It) ai.turnLeft(1) turn = 0 else : #Back Wall is closest- turn so that we are facing directly away from it if backLeftWall < backRightWall: ai.turnRight(1) #We need to turn right to face more directly away from it turn = 1 if backLeftWall > backRightWall: # We need to turn left to face more directly away from it ai.turnLeft(1) turn = 0 #Rules for thrusting if speed < maxSpeed and frontWall > 100: #If we are moving slowly and we won't ram into anything, accelerate ai.thrust(1) thrust = 1 elif trackWall < 250 and (ai.angleDiff(heading, tracking) > 120): #If we are getting close to a wall, and we can thrust away from it, do so ai.thrust(1) thrust = 1 elif backWall < 20: #If there is a wall very close behind us, get away from it ai.thrust(1) thrust = 1 if abs(calcDir - heading) < shotAngle : #If we are close to the current proper trajectory for a shot then fire ai.fireShot() shoot = 1 #adjust the the learning NN infile = open("myBotWeights.txt","r") weight = eval(infile.read()) infile.close() sendData = getSendData(turn, thrust, shoot) weight = adjustNN(sendData, 21, 8, 3, weight) outfile = open("myBotWeights.txt","w") outfile.write(str(weight)) outfile.close()