Add 2 legns in hisory 003a folder

pull/1/head
Yong Zhu 5 years ago
parent c0012ed968
commit 6fdf44d86b

@ -90,6 +90,7 @@ Frog: 这是人工生命的主体,目前起名叫青蛙(Frog),其实叫什
另外,这次更新加强了暂停功能,可以在脑图任一时刻暂停,并加上了脑图的剖面显示。所有脑图快捷键有: T:顶视 F前视 L:左视 R:右视 X:斜视 方向键:剖视 空格:暂停 鼠标操作:缩放旋转平移
![result6](https://gitee.com/drinkjava2/frog/raw/master/result6_letter.gif)
2019-11-26 优化了一下程序用8个汉字来进行模式识别原理演示但容错性依然没有变形、变位后的文字识别率很差。以后要考虑借签算法中的侧抑制、卷积、分层等原理来提高它的容错性这方面算法已经很成熟了目前只需要拿来主义用图形化模拟的方式来实现。但总体上算法和图形化模拟是两条路算法通常可以用模拟的方式来表达但不是所有模拟都可以归纳成算法因为模拟(或者说软件本身)有时会非常复杂,不容易总结出规律。也就是说模拟的表现力比算法更强,但模拟的缺点是资源消耗大。
2019-12-27 在history\003a_legs目录下依然是2维脑)尝试给青蛙加两条腿,看它能不能自动学会走路。一条腿位于下方,一条腿位于右侧,每条腿有位置感觉细胞、抬腿、落腿运动和感觉细胞,转动腿运动细胞。只有当腿落下且转动时青蛙才会位移。经过一段时间的生存汰淘之后,青蛙自动进化出会利用腿走路了,但效果不太理想,找食效率不高,往往只能朝一个方向利用单条腿前进,但至少这是青蛙第一次利用腿来走路,有兴趣的可以运行试试看。
## 运行方式 | Run
运行core或history各个子目录下的run.bat批处理文件即可启动运行history下有多个子目录按时间顺序按列存放着这个项目演化过程中的主要历史版本供演示。

@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

@ -0,0 +1,2 @@
call mvn eclipse:eclipse
call pause

@ -0,0 +1,102 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.gitee.drinkjava2</groupId>
<artifactId>frog003a</artifactId>
<packaging>jar</packaging>
<version>1.0</version>
<name>frog</name>
<description>An artificial life test project</description>
<url>https://gitee.com/drinkjava2/jsqlbox/frog</url>
<issueManagement>
<system>gitee Issue</system>
<url>https://gitee.com/drinkjava2/jsqlbox/frog/issues</url>
</issueManagement>
<licenses>
<license>
<name>The Apache Software License, Version 2.0</name>
<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
</license>
</licenses>
<developers>
<developer>
<name>Yong Zhu</name>
<email>yong9981@gmail.com</email>
<url>https://gitee.com/drinkjava2/</url>
</developer>
</developers>
<scm>
<connection>scm:git@gitee.com:drinkjava2/frog.git</connection>
<developerConnection>scm:git@gitee.com:drinkjava2/frog.git</developerConnection>
<url>git@gitee.com:drinkjava2/frog.git</url>
</scm>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
<!-- Release on Java8 -->
<version.java>1.8</version.java>
<version.javadoc>6</version.javadoc>
<version.compiler-plugin>3.3</version.compiler-plugin>
<version.war-plugin>2.6</version.war-plugin>
<version.clean-plugin>3.0.0</version.clean-plugin>
<version.resources-plugin>2.7</version.resources-plugin>
<version.surefire-plugin>2.19</version.surefire-plugin>
<version.jar-plugin>2.6</version.jar-plugin>
<version.source-plugin>2.4</version.source-plugin>
<version.javadoc-plugin>2.10.3</version.javadoc-plugin>
<version.gpg-plugin>1.6</version.gpg-plugin>
</properties>
<dependencies>
<!--dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency-->
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${version.compiler-plugin}</version>
<configuration>
<source>${version.java}</source>
<target>${version.java}</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.1.2</version>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<useUniqueVersions>false</useUniqueVersions>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>com.github.drinkjava2.frog.Application</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
<profiles>
</profiles>
</project>

@ -0,0 +1,4 @@
call mvn clean compile
cd target\classes
java -classpath ".;*" com.github.drinkjava2.frog.Application
@pause

@ -0,0 +1,2 @@
mvn clean package
java -jar target/frog-*.jar

@ -0,0 +1,88 @@
package com.github.drinkjava2.frog;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import javax.swing.JButton;
import javax.swing.JFrame;
import com.github.drinkjava2.frog.brain.BrainPicture;
/**
* Application's main method start the program
*
* @author Yong Zhu
* @since 1.0
*/
public class Application {
/** SHOW first frog's brain structure */
public static boolean SHOW_FIRST_FROG_BRAIN = false;
public static final String CLASSPATH;
static {
String classpath = new File("").getAbsolutePath();
int i = classpath.indexOf("\\frog\\");
if (i > 0)
CLASSPATH = classpath.substring(0, i) + "\\frog\\";// windows
else
CLASSPATH = classpath + "/"; // UNIX
}
public static JFrame mainFrame = new JFrame();
public static Env env = new Env();
public static BrainPicture brainPic = new BrainPicture(Env.ENV_WIDTH + 5, 0, Env.FROG_BRAIN_WIDTH,
Env.FROG_BRAIN_DISP_WIDTH);
public static void main(String[] args) throws InterruptedException {
mainFrame.setLayout(null);
mainFrame.setSize(Env.ENV_WIDTH + 20, Env.ENV_HEIGHT + 100); // 窗口大小
mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 关闭时退出程序
mainFrame.add(env);
mainFrame.add(brainPic);
JButton button = new JButton("Show first frog's brain");
int buttonWidth = 180;
int buttonHeight = 22;
int buttonXpos = Env.ENV_WIDTH / 2 - buttonWidth / 2;
button.setBounds(buttonXpos, Env.ENV_HEIGHT + 8, buttonWidth, buttonHeight);
ActionListener al = new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
SHOW_FIRST_FROG_BRAIN = !SHOW_FIRST_FROG_BRAIN;
if (SHOW_FIRST_FROG_BRAIN) {
button.setText("Hide first frog's brain");
int y = Env.ENV_HEIGHT + 100;
if (Env.FROG_BRAIN_DISP_WIDTH + 41 > y)
y = Env.FROG_BRAIN_DISP_WIDTH + 41;
mainFrame.setSize(Env.ENV_WIDTH + Env.FROG_BRAIN_DISP_WIDTH + 25, y);
} else {
button.setText("Show first frog's brain");
mainFrame.setSize(Env.ENV_WIDTH + 20, Env.ENV_HEIGHT + 100);
}
}
};
button.addActionListener(al);
mainFrame.add(button);
JButton stopButton = new JButton("Pause");
stopButton.setBounds(buttonXpos, Env.ENV_HEIGHT + 35, buttonWidth, buttonHeight);
ActionListener a2 = new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
Env.pause = !Env.pause;
if (Env.pause) {
stopButton.setText("Resume");
} else {
stopButton.setText("Pause");
}
}
};
stopButton.addActionListener(a2);
mainFrame.add(stopButton);
mainFrame.setVisible(true);
env.run();
}
}

@ -0,0 +1,115 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;
import com.github.drinkjava2.frog.brain.Cell;
import com.github.drinkjava2.frog.brain.Organ;
import com.github.drinkjava2.frog.egg.Egg;
import com.github.drinkjava2.frog.objects.Material;
/**
* Frog = organs + brain cells
*
* Group
*
* @author Yong Zhu
* @since 1.0
*/
public class Frog {
/** brain cells */
public List<Cell> cells = new ArrayList<>();
/** organs */
public List<Organ> organs = new ArrayList<>();
public int x; // frog在Env中的x坐标
public int y; // frog在Env中的y坐标
public long energy = 100000; // 青蛙的能量为0则死掉
public boolean alive = true; // 设为false表示青蛙死掉了将不参与计算和显示以节省时间
public int ateFood = 0;
// 青蛙有两只脚,不是自动进化而来的,而是直接赋予它(以后也可以考虑用个数随机生成、可感、可控、互锁的积木块来模拟运动器官本身的自动生成)
public int bFootPos = 0; // 底部脚的水平位置, -5 to 5
public String bFootStatus = "UP"; // 底部脚的状态只有UP和DOWN两种状态
public int rFootPos = 0;// 右侧脚的水平位置, -5 to 5
public String rFootStatus = "UP";// 右侧脚的状态只有UP和DOWN两种状态
static Image frogImg;
static {
try {
frogImg = ImageIO.read(new FileInputStream(Application.CLASSPATH + "frog.png"));
} catch (Exception e) {
e.printStackTrace();
}
}
public Frog(int x, int y, Egg egg) {
this.x = x;
this.y = y;
for (Organ org : egg.organs)
organs.add(org);
}
public void initOrgans() {
for (Organ org : organs)
org.initFrog(this);// 每个新器官初始化如果是Group类它们会生成许多脑细胞
}
/** Find a organ in frog by organ's name */
@SuppressWarnings("unchecked")
public <T extends Organ> T findOrganByName(String organName) {// 根据器官名寻找器官,但不是每个器官都有名字
for (Organ o : organs)
if (organName.equalsIgnoreCase(o.name))
return (T) o;
return null;
}
public boolean active(Env v) {
// 如果能量小于0则死、出界、与非食物的点重合则判死
if (!alive || energy < 0 || Env.outsideEnv(x, y) || Env.bricks[x][y] >= Material.KILLFROG) {
energy -= 100; // 死掉的青蛙也要消耗能量,确保淘汰出局
alive = false;
return false;
}
energy -= 20;
for (Organ o : organs) {
o.active(this);
}
return alive;
}
public void show(Graphics g) {// 显示青蛙的图象
if (!alive)
return;
g.drawImage(frogImg, x - 8, y - 8, 16, 16, null);
if (bFootStatus == "UP")
g.setColor(Color.BLACK);
else
g.setColor(Color.RED);
g.drawLine(x, y, x + bFootPos, y + 10);// 画底脚
if (rFootStatus == "UP")
g.setColor(Color.BLACK);
else
g.setColor(Color.RED);
g.drawLine(x, y, x + 10, y + rFootPos); // 画右脚
}
}

@ -0,0 +1,128 @@
package com.github.drinkjava2.frog.brain;
import static java.awt.Color.BLUE;
import static java.awt.Color.CYAN;
import static java.awt.Color.GREEN;
import static java.awt.Color.MAGENTA;
import static java.awt.Color.ORANGE;
import static java.awt.Color.RED;
import static java.awt.Color.YELLOW;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
import com.github.drinkjava2.frog.Application;
import com.github.drinkjava2.frog.Frog;
/**
* BrainPicture show first frog's brain structure, for debug purpose only
*
* @author Yong Zhu
* @since 1.0
*/
@SuppressWarnings("serial")
public class BrainPicture extends JPanel {
private float brainWidth; // real brain width
private int brainDispWidth; // screen display width
private Color color = Color.BLACK;
public void setColor(Color c) {
color = c;
}
public BrainPicture(int x, int y, float brainWidth, int brainDispWidth) {
super();
this.setLayout(null);// 空布局
this.brainDispWidth = brainDispWidth;
this.brainWidth = brainWidth;
this.setBounds(x, y, brainDispWidth + 1, brainDispWidth + 1);
}
public void drawZone( Zone z) {Graphics g = this.getGraphics();
g.setColor(color);
float rate = brainDispWidth / brainWidth;
int x = Math.round(z.x * rate);
int y = Math.round(z.y * rate);
int radius = Math.round(z.r * rate);
g.drawRect(x - radius, y - radius, radius * 2, radius * 2);
}
public void drawCircle( Zone z) {Graphics g = this.getGraphics();
g.setColor(color);
float rate = brainDispWidth / brainWidth;
int x = Math.round(z.x * rate);
int y = Math.round(z.y * rate);
g.drawArc(x - 5, y - 5, 10, 10, 0, 360);
}
public void fillZone( Zone z) {Graphics g = this.getGraphics();
g.setColor(color);
float rate = brainDispWidth / brainWidth;
int x = Math.round(z.x * rate);
int y = Math.round(z.y * rate);
int radius = Math.round(z.r * rate);
g.fillRect(x - radius, y - radius, radius * 2, radius * 2);
}
public void drawLine(Zone z1, Zone z2) {
Graphics g = this.getGraphics();
g.setColor(color);
float rate = brainDispWidth / brainWidth;
int x1 = Math.round(z1.x * rate);
int y1 = Math.round(z1.y * rate);
int x2 = Math.round(z2.x * rate);
int y2 = Math.round(z2.y * rate);
g.drawLine(x1, y1, x2, y2);
}
public void drawText( Zone z, String text) {Graphics g = this.getGraphics();
g.setColor(color);
float rate = brainDispWidth / brainWidth;
int x = Math.round(z.x * rate);
int y = Math.round(z.y * rate);
g.drawString(text, x - text.length() * 3 - 2, y);
}
private static final Color[] rainbow = new Color[] { RED, ORANGE, YELLOW, GREEN, CYAN, BLUE, MAGENTA };
private static int nextColor = 0;
public static Color nextRainbowColor() {
if (nextColor == rainbow.length)
nextColor = 0;
return rainbow[nextColor++];
}
public static Color color(float i) {
if (i == 0)
return Color.black;
if (i == 1)
return Color.RED;
if (i <= 3)
return Color.ORANGE;
if (i <= 10)
return Color.YELLOW;
if (i <= 20)
return Color.GREEN;
if (i <= 50)
return Color.CYAN;
if (i <= 100)
return Color.BLUE;
return Color.MAGENTA;
}
public void drawBrainPicture(Frog frog) {
if (!Application.SHOW_FIRST_FROG_BRAIN)
return;
Graphics g = this.getGraphics();// border
g.setColor(Color.WHITE);
g.fillRect(0, 0, brainDispWidth, brainDispWidth);
g.setColor(Color.black);
g.drawRect(0, 0, brainDispWidth, brainDispWidth);
for (Organ organ : frog.organs)
organ.drawOnBrainPicture(frog, this); // each organ draw itself
}
}

@ -0,0 +1,34 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain;
/**
* Cell is the basic unit of frog's brain
*
* @author Yong Zhu
* @since 1.0
*/
public class Cell {
public static final float MAX_ENERGY_LIMIT = 100.0f;
// this cell belong to frog's which organ
public Organ organ;
// inputs of cell
public Input[] inputs; // 每个细胞有一组输入触突
// outputs of cell
public Output[] outputs; // 每个细胞有一组输出触突
// energy of cell, energy got from food
public float energy; // 每个细胞当前的能量值
}

@ -0,0 +1,26 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain;
/**
* Input is the sensor of nerve cell
*
* @author Yong Zhu
* @since 1.0
*/
@SuppressWarnings("serial")
public class Input extends Zone {
public Cell cell; // 这个输入触突属于哪个脑细胞
public Input(Zone z) {
super(z);
}
}

@ -0,0 +1,109 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain;
import java.awt.Color;
import com.github.drinkjava2.frog.Application;
import com.github.drinkjava2.frog.Frog;
/**
* Organ is a part of frog, organ can be saved in egg
*
*
*
* @author Yong Zhu
* @since 1.0.4
*/
public class Organ extends Zone {
private static final long serialVersionUID = 1L;
public String name; // 显示在脑图上的器官名称,可选
public long fat = 0; // 如果活跃多fat值高则保留及变异的可能性大反之则很可能丢弃掉
// public float organWasteEnergy = 0.05f; //
// 器官在每个测试循环中需要消耗青蛙多少能量,可以通过调节这个参数抑制器官数量无限增长
public float organActiveEnergy = 1; // 输出器官激活需要消耗每个脑细胞多少能量
public float organOutputEnergy = 2; // 感觉器官激活会给每个脑细胞增加多少能量
public boolean initilized; // 通过这个标记判断是否需要手工给定它的参数初值
public boolean actived = false;
public boolean allowBorrow() { // 是否允许在精子中将这个器官借出
return false;
}
/** Each loop step call active method, Child class can override this method */
public void active(Frog f) { // 每一步都会调用器官的active方法 ,缺省啥也不干
}
/** If active in this organ's zone? */
public boolean activedByCells(Frog f) { // 如果一个细胞能量>10,且它的输出触突位于这个器官内,则器官被激活
for (Cell cell : f.cells) {
if (cell.energy > organActiveEnergy)
for (Output output : cell.outputs) { //
if (this.nearby(output)) {
cell.organ.fat++;
cell.energy -= 30;//
return true;
}
}
}
return false;
}
/** Active other cells */
public void activeOtherCells(Frog f) {// 与activedByCells相反它将器官的状态转化为输出能量激活与它相关的其它细胞区
for (Cell cell : f.cells) {
if (cell.energy > 0)
cell.energy--;
if (cell.energy < Cell.MAX_ENERGY_LIMIT)
for (Input input : cell.inputs)
if (input.nearby(this)) // if input zone nearby this zone
cell.energy += organOutputEnergy;
}
}
/** Set X, Y, Radius, name of current Organ */
public Organ setXYRN(float x, float y, float r, String name) {
this.setXYR(x, y, r);
this.name = name;
return this;
}
/** Child class can override this method to drawing picture */
public void drawOnBrainPicture(Frog f, BrainPicture pic) {// 把自已这个器官在脑图上显示出来,子类可以重写这个方法
if (!Application.SHOW_FIRST_FROG_BRAIN)
return;
pic.setColor(Color.BLACK); // 缺省是黑色
pic.drawZone(this);
if (this.name != null)
pic.drawText(this, String.valueOf(this.name));
if (actived)
pic.fillZone(this);
}
/** Only call once when frog created , Child class can override this method */
public void initFrog(Frog f) { // 仅在Frog生成时这个方法会调用一次缺省啥也不干通常用于Group子类的初始化
}
/** Only call once after organ be created by new() method */
public Organ[] vary() { // 在下蛋时每个器官会调用这个方法,缺省返回一个类似自已的副本,子类通常要覆盖这个方法
Organ newOrgan = null;
try {
newOrgan = this.getClass().newInstance();
} catch (Exception e) {
throw new UnknownError("Can not make new Organ copy for " + this);
}
copyXYR(this, newOrgan);
newOrgan.name = this.name;
newOrgan.fat = this.fat;
return new Organ[] { newOrgan };
}
}

@ -0,0 +1,26 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain;
/**
* Output can active other nerve cell's input
*
* @author Yong Zhu
* @since 1.0
*/
@SuppressWarnings("serial")
public class Output extends Zone {
public Cell cell; // 这个输出触突属于哪个脑细胞
public Output(Zone z) {
super(z);
}
}

@ -0,0 +1,84 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain;
import java.io.Serializable;
import com.github.drinkjava2.frog.Env;
/**
* Zone represents a rectangle zone in brain
*
* @author Yong Zhu
* @since 1.0
*/
public class Zone implements Serializable {
private static final long serialVersionUID = 1L;
public float x;
public float y;
public float r;// r为这个矩形区边长的一半
public Zone() {
// 空构造器不能省
}
public Zone(float x, float y, float r) {// 用x,y,r来构造
this.x = x;
this.y = y;
this.r = r;
if (this.x < 0)
this.x = 0;
if (this.y < 0)
this.y = 0;
if (this.x > Env.FROG_BRAIN_WIDTH)
this.x = Env.FROG_BRAIN_WIDTH;
if (this.y > Env.FROG_BRAIN_WIDTH)
this.y = Env.FROG_BRAIN_WIDTH;
}
public Zone(Zone z) {// 用另一个Zone来构造
this.x = z.x;
this.y = z.y;
this.r = z.r;
}
public boolean nearby(Zone z) {
float dist = r + z.r;
return (Math.abs(x - z.x) < dist && Math.abs(y - z.y) < dist);
}
public int roundX() {
return Math.round(x);
}
public int roundY() {
return Math.round(y);
}
public static void copyXY(Zone from, Zone to) {
to.x = from.x;
to.y = from.y;
}
public static void copyXYR(Zone from, Zone to) {
to.x = from.x;
to.y = from.y;
to.r = from.r;
}
public void setXYR(float x, float y, float r) {
this.x = x;
this.y = y;
this.r = r;
}
}

@ -0,0 +1,34 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.group;
import com.github.drinkjava2.frog.brain.Organ;
/**
* Group presents a rectangle organ zone, Group only arranges a group of cells
*
* 2.0CellGroup线2.0Group,Group
*
* CellGroupGroupGroup,
* Group Group
* Group Group
*
* GroupGroup,fatGroup
* GroupGroup"播种机"
* Group()Group
*
* @author Yong Zhu
* @since 1.0
*/
public abstract class Group extends Organ {
private static final long serialVersionUID = 1L;
}

@ -0,0 +1,100 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.group;
import java.awt.Color;
import com.github.drinkjava2.frog.Env;
import com.github.drinkjava2.frog.Frog;
import com.github.drinkjava2.frog.brain.BrainPicture;
import com.github.drinkjava2.frog.brain.Cell;
import com.github.drinkjava2.frog.brain.Input;
import com.github.drinkjava2.frog.brain.Organ;
import com.github.drinkjava2.frog.brain.Output;
import com.github.drinkjava2.frog.brain.Zone;
import com.github.drinkjava2.frog.util.RandomUtils;
/**
* RandomConnectGroup
*
* GroupCellGroupZone
* frogRandomConnectGroup
*
* (Group )
*
* @author Yong Zhu
* @since 1.0
*/
public class RandomConnectGroup extends Group {
private static final long serialVersionUID = 1L;
public Zone inputZone; // 输入触突区
public Zone outputZone; // 输出触突区
@Override
public boolean allowBorrow() { // 是否允许在精子中将这个器官借出
return true;
}
@Override
public void initFrog(Frog f) {
if (!initilized) {
initilized = true;
// organWasteEnergy=.05f;
x = Env.FROG_BRAIN_WIDTH / 2;
y = Env.FROG_BRAIN_WIDTH / 2;
r = Env.FROG_BRAIN_WIDTH / 2;
inputZone = RandomUtils.randomPosInAnyFrogOrgan(f);
outputZone = RandomUtils.randomPosInAnyFrogOrgan(f);
}
this.fat = 0;// 每次fat清0因为遗传下来的fat不为0
Cell c = new Cell();
Input in = new Input(inputZone);
in.cell = c;
c.inputs = new Input[] { in };
Output out = new Output(outputZone);
out.cell = c;
c.outputs = new Output[] { out };
c.organ = this;
f.cells.add(c);
}
@Override
public Organ[] vary() {
if (fat <= 0)// 如果胖值为0表示这个组的细胞没有用到可以小概率丢掉它了
if (RandomUtils.percent(30))
return new Organ[] {};
if (RandomUtils.percent(3)) // 有1%的几率丢掉它,防止这个器官数量只增不减
return new Organ[] {};
return new Organ[] { this };
}
@Override
public void drawOnBrainPicture(Frog f, BrainPicture pic) {// 把自已这个器官在脑图上显示出来
if (fat <= 0)
pic.setColor(Color.LIGHT_GRAY); // 没用到? 灰色
else
pic.setColor(Color.red); // 用到了?红色
pic.drawLine(inputZone, outputZone);
pic.drawZone(this);
pic.drawZone(inputZone);
pic.fillZone(outputZone);
if (fat > 0) {
pic.setColor(Color.red);
pic.drawCircle(outputZone); // 如果胖了,表示激活过了,下次下蛋少不了这一组
}
}
}

@ -0,0 +1,47 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.organ;
import com.github.drinkjava2.frog.Frog;
import com.github.drinkjava2.frog.brain.Cell;
import com.github.drinkjava2.frog.brain.Input;
import com.github.drinkjava2.frog.brain.Organ;
/**
* Active always keep active
*
*
*/
public class Active extends Organ {//以前的实验发现添加一个始终激活的区比用Hungry来驱动更能提高找食效率
private static final long serialVersionUID = 1L;
@Override
public void initFrog(Frog f) {
if (!initilized) {
initilized = true;
organOutputEnergy = 2;
}
}
@Override
public void active(Frog f) {
for (Cell cell : f.cells) {
if (cell.energy > 0)
cell.energy--;
if (cell.energy < Cell.MAX_ENERGY_LIMIT)
for (Input input : cell.inputs)
if (input.nearby(this)) // if input zone near by happy zone
cell.energy += organOutputEnergy;
}
}
}

@ -0,0 +1,33 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.organ;
import com.github.drinkjava2.frog.Frog;
import com.github.drinkjava2.frog.brain.Organ;
/**
* Move down frog 1 unit if outputs of nerve cells active in this zone
*/
public class BFootDrop extends Organ {
private static final long serialVersionUID = 1L;
@Override
public void active(Frog f) {
if (f.bFootStatus == "DOWN")
return;
if (activedByCells(f)) {
actived = true;
f.bFootStatus = "DOWN";
} else
actived = false;
}
}

@ -0,0 +1,31 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.organ;
import com.github.drinkjava2.frog.Frog;
import com.github.drinkjava2.frog.brain.Organ;
/**
* Move down frog 1 unit if outputs of nerve cells active in this zone
*/
public class BFootFeelDown extends Organ {
private static final long serialVersionUID = 1L;
@Override
public void active(Frog f) {
if (f.bFootStatus == "DOWN") {
actived = true;
activeOtherCells(f);
} else
actived = false;
}
}

@ -0,0 +1,31 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.organ;
import com.github.drinkjava2.frog.Frog;
import com.github.drinkjava2.frog.brain.Organ;
/**
* Move down frog 1 unit if outputs of nerve cells active in this zone
*/
public class BFootFeelUp extends Organ {
private static final long serialVersionUID = 1L;
@Override
public void active(Frog f) {
if (f.bFootStatus == "UP") {
actived = true;
activeOtherCells(f);
} else
actived = false;
}
}

@ -0,0 +1,35 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.organ;
import com.github.drinkjava2.frog.Frog;
import com.github.drinkjava2.frog.brain.Organ;
/**
* Move down frog 1 unit if outputs of nerve cells active in this zone
*/
public class BFootMoveLeft extends Organ {
private static final long serialVersionUID = 1L;
@Override
public void active(Frog f) {
if (f.bFootPos <= -5)
return;
if (activedByCells(f)) {
actived = true;
f.bFootPos--;
if (f.bFootStatus == "DOWN" && f.rFootStatus == "UP")
f.x++;
} else
actived = false;
}
}

@ -0,0 +1,35 @@
/*
* Copyright 2018 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by
* applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
* OF ANY KIND, either express or implied. See the License for the specific
* language governing permissions and limitations under the License.
*/
package com.github.drinkjava2.frog.brain.organ;
import com.github.drinkjava2.frog.Frog;
import com.github.drinkjava2.frog.brain.Organ;
/**
* Move down frog 1 unit if outputs of nerve cells active in this zone
*/
public class BFootMoveRight extends Organ {
private static final long serialVersionUID = 1L;
@Override
public void active(Frog f) {
if (f.bFootPos >= 5)
return;
if (activedByCells(f)) {
actived = true;
f.bFootPos++;
if (f.bFootStatus == "DOWN" && f.rFootStatus == "UP")
f.x--;
} else
actived = false;
}
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save