Free robocup soccer simulator 11.1.0 software for linux

The RoboCup Soccer Simulator project is a platform for evaluating AI agents.
The RoboCup Soccer Simulator is a platform for evaluating multiple autonomous intelligent agents in a realworld-like domain.
The simulator allows two teams of 11 players and one coach to interact in a simulated game of soccer.
The team members connect to the simulator using UDP sockets and must perform complex behaviors using only a few basic commands, primarily dash, kick, turn, and catch, based on noisy and infrequent sensor information provided by the simulator.
This simulator is used in the simulation league of the RoboCup competition.
Enhancements:
- Just updated a minor version number. Official relasese for the RoboCup2007.

Jimsim Network Simulator project can emulate several routers connected via virutal networks. You can connect to the routers with your own favorite telnet program.
Connecting to the Virtual Routers
Use your favorite telnet program to connect to each of the virtual routers. For example:
For router 1 type:
C:>telnet localhost 10000
For router 2 type:
C:>telnet localhost 10001
For router 3 type:
C:>telnet localhost 10002
Network Layout
Currently the network is configured like this:
access-list [1-99] [permit/deny] [ ip wildcard-mask | host a.b.c.d | any ]
ip acccess-list [standard] [name]
ip access-group
show access-list
show ip interface
show ip interface brief
debug interface
encapsulation [hdlc,ppp] (serial interfaces only)
bandwidth
clock rate (serial interfaces)
interface loopback0
User commands:
?
enable
exit
ping ip
show cdp
show cdp neigh
show cdp neigh detail
show interface
show interface e0,eth0,etc
show ip route
show version
Enable commands:
clear counters
clear counters interface
config terminal
copy running startup
copy startup running
debug all
debug ip routing
debug ip eigrp
debug cdp
disable
exit
reload
show run
show startup
show ip eigrp neighbors
show ip eigrp topology
traceroute ip
undebug all
undebug ip routing
undebug ip eigrp
undebug cdp
Config commands:
cdp run
enable password password
end
hostname
banner motd delimiter
banner exec delimiter
banner login delimiter
ip route network netmask dest
interface e0,eth0,etc
bandwidth value
ip address addr netmask
description
cdp enable
shutdown
line con0, console0, console 0
login
login local
password passwd
router eigrp number
network a.b.c.d
service password-encryption
user username password password
Version restrictions:
- The EIGRP support is very basic. Just the network command for now. (Neighbors dont expire.) You can disable EIGRP with "no router eigrp process_id"
- The routing table isnt 100% correct. It doesnt summarize subnets. Nor does it understand multiple routes to the same destination. This will be fixed in the next version.
- Traceroute seems to count extra hops. Its counting each remote interface on a router as a hop. So, when you traceroute from router1 to router3, it counts router2 twice (once for 192.168.1.2 and 10.1.1.1)

GNUSim8085 is a graphical simulator for the Intel 8085 microprocessor.
GNUSim8085 is a simulator and assembler for the Intel 8085 Microprocessor, in GNOME environment.
GNU 8085 Simulator contains an inline assembler and a debugger.
Enhancements:
- New: Use gtksourceview as editor component.
- Fix: Syntax highlighting working again.
- Fix: About dialog does not close by pressing close button.

Simulator 8085 is a simulator of the 8085 MP for KDE (3.1 and 3.2pre) that allows you write code in a text editor.

After assembling, the hex code is readable alongside the mnemonics. It can handle jumping labels and strings, and you can choose beetween a single or multiple window interface. All 8085 MP inclusive interrupts work.

Vamos Automotive Simulator project, as the name suggest is an automotive simulation framework with an emphasis on thorough physical modeling and good C++ design. Vamos includes a real-time, first-person, 3D driving application.

Vamos is young and its goals are only partially met. I invite anyone whos interested to contribute.

Thorough physical modeling

Vamos models most major systems of a car. The drivetrain includes a simulation of the engine, clutch, transmission and a limited-slip differential. Tires and suspension are also modeled. If I missed something, let me know.

Good C++ Design

The geometry, track, car and world modules are in their own namespaces. Care has been taken to avoid cyclic dependencies. Standard Library components like strings, vectors and maps are favored over arrays. Some of the modules and classes have aged more gracefully than others. If you see a design area that needs improvement, feel free to pitch in.

Fungus Agent Simulator project consists of a distributed multi-agent-based simulator.
Fungus Agent Simulator is a distributed multi-agent-based simulator that lets users easily create artificial life simulations. It uses a modular and a extensible architecture. A tiny scripting language (named Mycelium) is provided.
With Mycelium, users can easily build a simulation. Users can access the information traveling between the agents. Multiple scheduling models and multiple view are provided.
Main features:
- Agent
- Agent Based Simulation
- Agent could be a object or a threaded object
- Hierarchical agent
- Communication
- Messages passing communication model
- Discrete Event
- Communications canals are accessible
- Kernel
- Manage Scheduling Techniques
- distributed simulation
- Graphical user interface
- Simulator is written in Java

MOS 6502 Simulator is sort of an emulator for a 6502 chip. Theres virtually nothing apart from the CPU (minus BCD operations). It also bears no heed to instruction timings.

Whilst (apart from those two things) it successfully simulates the CPU there were a few design flaws, which led me not to continue with it:

- I wrote it in C++.

As the 6502 had no dedicated IO bus, everything was done via memory. I had the idea of having a pure virtual class which provided a generic interface, then as I wrote devices to sit in the memory space, they could just override portions of it, or trap on writes or something.

Whilst writing this, I kept getting the feeling I should have written it in asm instead Especially for manipulating flags and rotates and stuff. (as I could have just rotated AL, for example, rather than the mess I have in the C++ code.

- Sloppy instruction decoding.

I originally set out to decode the instructions properly, but there were lots of exceptions to the system used (esp. if I intended to support the 65C02 for example). This decended into a massive switch statement. I almost considered splitting it up to smaller files, and just #include them in the middle, just to make it more managable.

Also, as they are not in numerical order (grouped according to type, or addressing mode, cant remember atm) it wouldnt compile to a jump table. Does with optimisation on though.

The main thing that prompted me to write this was I found my BBC-B in the loft, and felt a pang of nostalgia for the hours wasted hunched over it in the lowest resolution text mode (IIRC mode 7 to save ram). I had the idea of writing a NES or BBC emulator, however it didnt get that far.

It has a pretty simple image format. The file must be >= 65536 bytes (64k) and that is simply the memory image for the system (16-bit address bus). There is a strange sort of ASCII text display at 0x200, which is ok enough for spewing a string to. As it was just thrown together in the space of 6 hours or so (took a long time to do the switch statement) its not very thouroughly documented, but hey.