User:Awesomeness - Revision history

Awesomeness: User page update

2010-01-23T03:51:21Z

User page update

Awesomeness: I'm back!

2010-01-19T17:54:56Z

I'm back!

Awesomeness: News

2009-05-31T19:02:20Z

News

Awesomeness: Typo

2009-05-09T17:09:28Z

Typo

Awesomeness: News edit

2009-05-09T17:08:23Z

News edit

Awesomeness: Fixing it up

2009-05-09T17:05:36Z

Fixing it up

Awesomeness: New progress on my new targeting idea! Plus, I found out my idea is ORIGINAL! YAY! Lol

2009-05-09T17:04:19Z

New progress on my new targeting idea! Plus, I found out my idea is ORIGINAL! YAY! Lol

Awesomeness: lol

2009-05-06T23:42:11Z

lol

Awesomeness: lol 'nother typo

2009-05-06T23:40:14Z

lol 'nother typo

Awesomeness: tweak tweak

2009-05-06T23:39:38Z

*tweak tweak*

@@ Line 33: / Line 33: @@
 == My Projects ==
-NEWS:  I'm back!  After lots of busy schoolcrap I've finally found the time again!
+NEWS:  I have decided to make a tutorial on [[Virtual Bullets]].  I'll finish it soon, but I have a busy weekend.
-Currently I am working on a robot called DodgeBot. It's named that because it was originally intended to dodge bullets.  I'm going to rename it when I think it's finished.  He has a superb movement system that dodges many, many bullets.  It gets 75% against [[N]],  which I'm very proud of =)   It is totally a one on one robot, and it's movement is stimulated by it's target shooting, which works because enemies usually shoot a lot XD
+NEWS:  Before I came back, I created a NanoBot called Elite.  It's melee oriented.  After I came back, I made him into [[PwnBot]], a 1-on-1 oriented version.  They are similar.  I'll post PwnBot in the repository soon; I'm almost done.
-DodgeBot has superb movement.  I like it a lot.  It's simple too!  However, the code in my opinion is a little on the long side (I'm not good at making code shorter) and it's gun isn't that good.  It never loses a lock once it's found a target!  Note that although DodgeBot does okay in melee, it is strictly a one-on-one robot.  I have discovered that many of my one-on-one bots do VERY well in melee too...
+I've finished!  Check it out at the [[Fission]] page.  EDIT:Now that I look back, it's not that great, lol.
 Anyway, I'm also working on my first NanoBot, and man, it's hard!  You have to seriously cut back on code.  It takes many sacrifices.  However, my new bot, Elite, is doing fine.  In a hundred rounds it gets 70% against [[N]], and a startling 64% against [[PulsarNano]], 22nd in the overall world rankings.  Elite seems to be very competitive.  I also made it on my own;  didn't take any code or ideas from anyone else.  I was just bored in study hall XD  He also gets 51% on NanoSatan.
@@ Line 50: / Line 49: @@
 '''Targeting Using Trees'''
+----
 I've had an interesting targeting idea using trees.  There would be one universal starting point, the stump, at the base of a "tree" of movement.  Say at the beginning of a battle the enemy bot acts like MyFirstBot, and move forward, stops, moves back, and stops.  Each branch on the tree would have what the robot did and how many times it's done that.  If the robot does this sequence again, it'd search through the tree and say, "Oh!  This looks like 'move forward, stop, move back, stop'!" and aim where it'd be in that sequence by the time the bullet would get there.  If it worked, add to the number of times that sequence has happened.  If it didn't, create a new branch that has what the bot really did.  Let's just say it works the second time.  The tree would look like:
 [[Image:Tree.png|463px|thumb|left|This!]]
@@ Line 62: / Line 61: @@
 * I've been working with trees, searches, and optimization in my compression program.
 * I simple combined these two ideas while daydreaming about random stuff.  My mind drifted to Robocode, then my compression program, and then I started thinking about them both, and...  BAM!  It hit me.  Literally.  I got the idea while tripping.  My jaw hit a wooden arm rest in my school auditorium and it hurt a lot.  But I came up with a new idea!  =D
@@ Line 71: / Line 69: @@
 ----
-I have made a few lists that record enemy data for the past 50 ticks, and I have made a TreeNode class to build the tree with.  I have a bunch of numbers to record and I've built a searcher.  You give it some data to search for, and it searches the whole tree (Well, if you search using the root node) for a match.  If it finds more than one match, it uses the one that occurs most.  It's very primitive though.  It doesn't so far use its parent node, looking to see if movement history matches it.  It needs a bunch of optimizing.  Also, by the way [[Nat]], I found out that my tree idea is totally different than [[LambdaBot|LambDaBot's]] tree idea.  Mine searches through a tree of movement, looking for matches and using that to predict it's movement, while [[LambdaBot]] uses trees to look through possible movement options, and finding long strings of moves (one move is one tick) and rating them by a "successfullness" rating, like how much of an advantage his position, bearing, and velocity will have in that position, like chess.
+I have made a few lists that record enemy data for the past 50 ticks, and I have made a TreeNode class to build the tree with.  I have a bunch of numbers to record and I've built a searcher.  You give it some data to search for, and it searches the whole tree (Well, if you search using the root node) for a match.  If it finds more than one match, it uses the one that occurs most.  It's very primitive though.  It doesn't so far use its parent node, looking to see if movement history matches it.  It needs a bunch of optimizing.  Also, by the way [[Nat]], I found out that my tree idea is totally different than [[LambdaBot|LambDaBot's]] tree idea.  Mine searches through a tree of movement, looking for matches and using that to predict the enemy's  movement, while [[LambdaBot]] uses trees to look through possible movement options, and finding long strings of moves (one move is one tick) and rating them by a "successfullness" rating, like how much of an advantage his position, bearing, and velocity will have in that position, like chess.
@@ Line 79: / Line 77: @@
+== Older News ==
 I haven't been around for a while.  I've been finishing my file compression program and making games.  I might be back in a while, but I'm not done yet.
 I have started on my targeting idea and made progress!

@@ Line 29: / Line 29: @@
 == About Me ==
-Hello!  I found this while looking around on the internet!  It's so cool!  Even though I'm only 13, I'm a pretty good at Java and really good at Python.
+Hello!  I found this while looking around on the internet!  It's so cool!  Even though I'm only 14, I'm a pretty good at Java and really good at Python.
 == My Projects ==
 Currently I am working on a robot called DodgeBot. It's named that because it was originally intended to dodge bullets.  I'm going to rename it when I think it's finished.  He has a superb movement system that dodges many, many bullets.  It gets 75% against [[N]],  which I'm very proud of =)   It is totally a one on one robot, and it's movement is stimulated by it's target shooting, which works because enemies usually shoot a lot XD

@@ Line 81: / Line 81: @@
 == Newest News ==
 I have started on my targeting idea and made progress!
 That bot, which was [[PwnBot]], never worked out.  I found there was nothing I could do with the bullet simulation.  Still, I learned a lot and I may use the VirtualBullet class I made in the future.
 Recently I have been working on my first really complicated bot.  I'm using trigonometry and having to invent my own formulas.  It's really hard because I'm only in seventh grade!  However, my bullet simulators and predictors are doing fine.

← Older revision		Revision as of 17:09, 9 May 2009
Line 69:		Line 69:
	----		----

−	I have made a few lists that record enemy data for the past 50 ticks, and I have made a TreeNode class to build the tree with. I have a bunch of numbers to record and I've built a searcher. You give it some data to search for, and it searches the whole tree (Well, if you search using the root node) for a match. If it finds more than one match, it uses the one that occurs most. It's very primitive though. It doesn't so far use its parent node, looking to see if movement history matches it. It needs a bunch of optimizing. Also, by the way [[Nat]], I found out that my tree idea is totally different than [[LambdaBot\|LambDaBot's]] tree idea. Mine searches through a tree of movement, looking for matches and using that to predict it's movement, while [[~~LambDaBot~~]] uses trees to look through possible movement options, and finding long strings of moves (one move is one tick) and rating them by a "successfullness" rating, like how much of an advantage his position, bearing, and velocity will have in that position, like chess.	+	I have made a few lists that record enemy data for the past 50 ticks, and I have made a TreeNode class to build the tree with. I have a bunch of numbers to record and I've built a searcher. You give it some data to search for, and it searches the whole tree (Well, if you search using the root node) for a match. If it finds more than one match, it uses the one that occurs most. It's very primitive though. It doesn't so far use its parent node, looking to see if movement history matches it. It needs a bunch of optimizing. Also, by the way [[Nat]], I found out that my tree idea is totally different than [[LambdaBot\|LambDaBot's]] tree idea. Mine searches through a tree of movement, looking for matches and using that to predict it's movement, while [[LambdaBot]] uses trees to look through possible movement options, and finding long strings of moves (one move is one tick) and rating them by a "successfullness" rating, like how much of an advantage his position, bearing, and velocity will have in that position, like chess.

← Older revision		Revision as of 17:08, 9 May 2009
Line 82:		Line 82:
	== Newest News ==		== Newest News ==

		+	I have started on my targeting idea and made progress!
		+
		+	That bot, which was [[PwnBot]], never worked out. I found there was nothing I could do with the bullet simulation. Still, I learned a lot and I may use the VirtualBullet class I made in the future.
		+
		+	== Older news ==

	Recently I have been working on my first really complicated bot. I'm using trigonometry and having to invent my own formulas. It's really hard because I'm only in seventh grade! However, my bullet simulators and predictors are doing fine.		Recently I have been working on my first really complicated bot. I'm using trigonometry and having to invent my own formulas. It's really hard because I'm only in seventh grade! However, my bullet simulators and predictors are doing fine.

@@ Line 45: / Line 45: @@
 == Research ==
-=== Current ===
+=== Current Research ===
 '''Targeting Using Trees'''
@@ Line 70: / Line 70: @@
 I have made a few lists that record enemy data for the past 50 ticks, and I have made a TreeNode class to build the tree with.  I have a bunch of numbers to record and I've built a searcher.  You give it some data to search for, and it searches the whole tree (Well, if you search using the root node) for a match.  If it finds more than one match, it uses the one that occurs most.  It's very primitive though.  It doesn't so far use its parent node, looking to see if movement history matches it.  It needs a bunch of optimizing.  Also, by the way [[Nat]], I found out that my tree idea is totally different than [[LambdaBot|LambDaBot's]] tree idea.  Mine searches through a tree of movement, looking for matches and using that to predict it's movement, while [[LambDaBot]] uses trees to look through possible movement options, and finding long strings of moves (one move is one tick) and rating them by a "successfullness" rating, like how much of an advantage his position, bearing, and velocity will have in that position, like chess.

← Older revision		Revision as of 23:42, 6 May 2009
Line 52:		Line 52:


−	Of course you can see there's no branches, it's just one long sequence. Say next time, the enemy tries to trick the robot by moving slightly differently once, and then switching back to the original movement. It would start out using the original movement; it moves forward, stops, but then, it turns and moves back, and stops! It would mess up the first time doing the original movement pattern, but then once it switches back he'd be hit by bullets again immediately. Because the original movement had more #, it was used. This doesn't mean the new movement pattern was ignored; another branch was created for it, it's just its # was smaller. # could be more statistical, (maybe the hit percentage when this sequence is used) you could add more things to consider in the tree, such as distance, just like [[segmentation]]! Unfortunately, unless # decreased over time, like data decay, and when it gets to 0 it disappears, the number of branches would increase exponentially. Anyway, to me it seems like [[Pattern Matching]], but you take in multiple factors into your decision making and pattern recognizing, which may, or may not, make it more accurate. I just came up with this. The idea was inspired by three things:	+	Of course you can see there's no branches, it's just one long sequence. Say next time, the enemy tries to trick the robot by moving slightly differently once, and then switching back to the original movement. It would start out using the original movement; it moves forward, stops, but then, it turns and moves back, changing the variable T, turn rate, and stops! It would mess up the first time doing the original movement pattern, but then once it switches back he'd be hit by bullets again immediately. Because the original movement had more #, it was used. This doesn't mean the new movement pattern was ignored; another branch was created for it, it's just its # was smaller. # could be more statistical, (maybe the hit percentage when this sequence is used) you could add more things to consider in the tree, such as distance, just like [[segmentation]]! Unfortunately, unless # decreased over time, like data decay, and when it gets to 0 it disappears, the number of branches would increase exponentially. Anyway, to me it seems like [[Pattern Matching]], but you take in multiple factors into your decision making and pattern recognizing, which may, or may not, make it more accurate. I just came up with this. The idea was inspired by three things:

← Older revision		Revision as of 23:40, 6 May 2009
Line 52:		Line 52:


−	Of course you can see there's no branches, it's just one long sequence. Say next time, the enemy tries to trick the robot by moving slightly differently once, and then switching back to the original movement. It would start out using the original movement; it moves forward, stops, but then, it turns and moves back, and stops! It would mess up the first time doing the original movement pattern, but then once it switches back he'd be hit by bullets again immediately. Because the original movement had more #, it was used. This doesn't mean the new movement pattern was ignored; another branch was created for it, it's just its # was smaller. # could be more statistical, (maybe the hit percentage when this sequence is used) you could add more things to consider in the tree, such as distance, just like [[segmentation]]! Unfortunately, unless # decreased over time, like data decay, and when it gets to 0 it disappears, the number of branches would increase exponentially. Anyway, to me it seems like [[Pattern Matching]], but you take in multiple factors into your decision making and pattern recognizing, which may, or may not, make it more accurate. I just came up with this. The idea was inspired by ~~two~~ things:	+	Of course you can see there's no branches, it's just one long sequence. Say next time, the enemy tries to trick the robot by moving slightly differently once, and then switching back to the original movement. It would start out using the original movement; it moves forward, stops, but then, it turns and moves back, and stops! It would mess up the first time doing the original movement pattern, but then once it switches back he'd be hit by bullets again immediately. Because the original movement had more #, it was used. This doesn't mean the new movement pattern was ignored; another branch was created for it, it's just its # was smaller. # could be more statistical, (maybe the hit percentage when this sequence is used) you could add more things to consider in the tree, such as distance, just like [[segmentation]]! Unfortunately, unless # decreased over time, like data decay, and when it gets to 0 it disappears, the number of branches would increase exponentially. Anyway, to me it seems like [[Pattern Matching]], but you take in multiple factors into your decision making and pattern recognizing, which may, or may not, make it more accurate. I just came up with this. The idea was inspired by three things:


Line 61:		Line 61:

	* I simple combined these two ideas while daydreaming about random stuff. My mind drifted to Robocode, then my compression program, and then I started thinking about them both, and... BAM! It hit me. Literally. I got the idea while tripping. My jaw hit a wooden arm rest in my school auditorium and it hurt a lot. But I came up with a new idea! =D		* I simple combined these two ideas while daydreaming about random stuff. My mind drifted to Robocode, then my compression program, and then I started thinking about them both, and... BAM! It hit me. Literally. I got the idea while tripping. My jaw hit a wooden arm rest in my school auditorium and it hurt a lot. But I came up with a new idea! =D
		+
		+

← Older revision		Revision as of 23:39, 6 May 2009
Line 53:		Line 53:

	Of course you can see there's no branches, it's just one long sequence. Say next time, the enemy tries to trick the robot by moving slightly differently once, and then switching back to the original movement. It would start out using the original movement; it moves forward, stops, but then, it turns and moves back, and stops! It would mess up the first time doing the original movement pattern, but then once it switches back he'd be hit by bullets again immediately. Because the original movement had more #, it was used. This doesn't mean the new movement pattern was ignored; another branch was created for it, it's just its # was smaller. # could be more statistical, (maybe the hit percentage when this sequence is used) you could add more things to consider in the tree, such as distance, just like [[segmentation]]! Unfortunately, unless # decreased over time, like data decay, and when it gets to 0 it disappears, the number of branches would increase exponentially. Anyway, to me it seems like [[Pattern Matching]], but you take in multiple factors into your decision making and pattern recognizing, which may, or may not, make it more accurate. I just came up with this. The idea was inspired by two things:		Of course you can see there's no branches, it's just one long sequence. Say next time, the enemy tries to trick the robot by moving slightly differently once, and then switching back to the original movement. It would start out using the original movement; it moves forward, stops, but then, it turns and moves back, and stops! It would mess up the first time doing the original movement pattern, but then once it switches back he'd be hit by bullets again immediately. Because the original movement had more #, it was used. This doesn't mean the new movement pattern was ignored; another branch was created for it, it's just its # was smaller. # could be more statistical, (maybe the hit percentage when this sequence is used) you could add more things to consider in the tree, such as distance, just like [[segmentation]]! Unfortunately, unless # decreased over time, like data decay, and when it gets to 0 it disappears, the number of branches would increase exponentially. Anyway, to me it seems like [[Pattern Matching]], but you take in multiple factors into your decision making and pattern recognizing, which may, or may not, make it more accurate. I just came up with this. The idea was inspired by two things:
		+

	* I've been curious if it was possible to do Guess Factor Targeting with the results of a Pattern Matcher as some of the segmentation.		* I've been curious if it was possible to do Guess Factor Targeting with the results of a Pattern Matcher as some of the segmentation.