Merge branch 'master' of github.com:imos/icfpc2020

Author: chokudai

.dockerignore

@@ -1,2 +1,3 @@
 /.cache
 /build
+/target

get_room.Dockerfile

@@ -0,0 +1,17 @@
+FROM rust:1.44.1-buster
+
+WORKDIR /solution
+COPY Cargo.toml Cargo.toml
+COPY Cargo.lock Cargo.lock
+COPY src src
+RUN cargo build --release --bin=get_room && \
+    cp ./target/release/get_room /usr/local/bin/get_room && \
+	rm -rf ./target ~/.cache /usr/local/cargo/registry || true
+ARG ENDPOINT
+ENV ENDPOINT=$ENDPOINT
+RUN mv /usr/local/bin/get_room /usr/local/bin/get_room-internal
+RUN echo '#!/usr/bin/env bash' >>/usr/local/bin/get_room && \
+    echo "exec /usr/local/bin/get_room-internal '$ENDPOINT' \"\$@\"" \
+        >>/usr/local/bin/get_room && \
+    chmod +x /usr/local/bin/get_room
+ENTRYPOINT ["/usr/local/bin/get_room"]

go/cmd/proxy/README.md

@@ -0,0 +1,15 @@
+## How to build
+
+```
+docker build -t imos/icfpc2020:proxy \
+    --build-arg ENDPOINT='https://icfpc2020-api.testkontur.ru/aliens/send?apiKey=*******' \
+    -f proxy.Dockerfile .
+```
+
+## How to use
+
+Bind your port (e.g., 12345) for the proxy server.
+
+```bash
+docker run -p 12345:8080 --rm -it imos/icfpc2020:proxy run
+```

go/cmd/proxy/main.go

@@ -1,47 +1,69 @@
 package main
 
 import (
+	"bytes"
+	"flag"
 	"fmt"
-	"log"
+	"io/ioutil"
 	"net/http"
-	"net/http/httputil"
+
+	"github.com/golang/glog"
 )
 
+var icfpcServerURL = flag.String("endpoint", "", "API endpoint")
+var port = flag.String("port", ":9000", "API endpoint")
+
+func handler(w http.ResponseWriter, r *http.Request) {
+	glog.Info("Processing request...")
+	if r.Body == nil {
+		glog.Errorf("body is empty")
+		w.WriteHeader(400)
+		return
+	}
+	defer r.Body.Close()
+	buf, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		glog.Errorf("body is broken: %#v", err)
+		w.WriteHeader(400)
+		return
+	}
+	fmt.Printf("REQUEST\t%s\n", string(buf))
+	resp, err := http.Post(*icfpcServerURL, "text/plain", bytes.NewBuffer(buf))
+	if err != nil {
+		glog.Errorf("POST failed: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+	if resp.Body == nil {
+		glog.Errorf("response body is empty")
+		w.WriteHeader(500)
+		return
+	}
+	defer resp.Body.Close()
+	buf, err = ioutil.ReadAll(resp.Body)
+	if err != nil {
+		glog.Errorf("failed to read response body: %#v", err)
+		w.WriteHeader(500)
+		return
+	}
+	fmt.Printf("RESPONSE\t%s\n", string(buf))
+	w.Header().Set("Content-Type", "text/plain")
+	if _, err := w.Write(buf); err != nil {
+		glog.Errorf("failed to respond")
+		w.WriteHeader(500)
+		return
+	}
+}
+
 func main() {
-	director := func(req *http.Request) {
-		url := *req.URL
-		url.Scheme = "https"
-		url.Host = "icfpc2020-api.testkontur.ru"
-		req.Host = url.Host
-		req.URL = &url
-		buf, _ := httputil.DumpRequest(req, false)
-		fmt.Println(string(buf))
-		// buffer, err := ioutil.ReadAll(request.Body)
-		// if err != nil {
-		// 	log.Fatal(err.Error())
-		// }
-		// req, err := http.NewRequest(request.Method, url.String(), bytes.NewBuffer(buffer))
-		// if err != nil {
-		// 	log.Fatal(err.Error())
-		// }
-		// req.Header = request.Header
-		// *request = *req
-	}
-	modifier := func(resp *http.Response) error {
-		buf, _ := httputil.DumpResponse(resp, true)
-		fmt.Println(string(buf))
-		return nil
-	}
-	rp := &httputil.ReverseProxy{
-		Director:       director,
-		ModifyResponse: modifier,
-	}
-	server := http.Server{
-		Addr:    ":9000",
-		Handler: rp,
-	}
-	fmt.Println("Started...")
-	if err := server.ListenAndServe(); err != nil {
-		log.Fatal(err.Error())
+	flag.Parse()
+	glog.Info("Initializing...")
+	if *icfpcServerURL == "" {
+		glog.Fatal("--endpoint flag is required")
+	}
+	http.HandleFunc("/", handler)
+	glog.Infof("Starting server on %s...", *port)
+	if err := http.ListenAndServe(*port, nil); err != nil {
+		glog.Fatal(err.Error())
 	}
 }

go/proxy.Dockerfile

@@ -0,0 +1,13 @@
+FROM golang:latest
+
+ARG ENDPOINT
+ENV ENDPOINT=$ENDPOINT
+WORKDIR /build
+COPY . .
+RUN go build -o /usr/local/bin/proxy-internal ./cmd/proxy
+RUN echo '#!/usr/bin/env bash' >>/usr/local/bin/proxy && \
+    echo "exec /usr/local/bin/proxy-internal --endpoint='$ENDPOINT' \"\$@\"" \
+        >>/usr/local/bin/proxy && \
+    chmod +x /usr/local/bin/proxy
+EXPOSE 8080
+ENTRYPOINT ["/usr/local/bin/proxy", "--logtostderr", "--port=:8080"]

script/arena.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+set -eux
+
+DATETIME="$(date "+%Y%m%d-%H%M%S")"
+ATTACKER="${1:-c090cc8}"
+DEFENDER="${2:-c090cc8}"
+ATTACKER_PORT="${3:-8001}"
+DEFENDER_PORT="${4:-8002}"
+
+DIR="logs/${DATETIME}-${ATTACKER}-vs-${DEFENDER}"
+mkdir -p "${DIR}"
+
+docker pull "imos/icfpc2020:${ATTACKER}"
+docker pull "imos/icfpc2020:${DEFENDER}"
+
+docker run --rm -p "${ATTACKER_PORT}:8080" --name="proxy-${ATTACKER_PORT}" imos/icfpc2020:proxy > "${DIR}/attacker.txt" &
+docker run --rm -p "${DEFENDER_PORT}:8080" --name="proxy-${DEFENDER_PORT}" imos/icfpc2020:proxy > "${DIR}/defender.txt" &
+
+KEYS=($(docker run --rm imos/icfpc2020:get_room))
+
+docker run --rm --net=host "imos/icfpc2020:${ATTACKER}" "http://localhost:${ATTACKER_PORT}/aliens/send" "${KEYS[0]}" >"${DIR}/attacker-stdout.txt" 2>"${DIR}/attacker-stderr.txt" &
+ATTACKER_PID=$!
+
+docker run --rm --net=host "imos/icfpc2020:${DEFENDER}" "http://localhost:${DEFENDER_PORT}/aliens/send" "${KEYS[1]}" >"${DIR}/defender-stdout.txt" 2>"${DIR}/defender-stderr.txt" &
+DEFENDER_PID=$!
+
+exit_code=1
+if wait "${ATTACKER_PID}" && wait "${DEFENDER_PID}"; then
+	exit_code=1
+fi
+
+docker kill "proxy-${ATTACKER_PORT}" &
+docker kill "proxy-${DEFENDER_PORT}" &
+wait || true
+
+exit "${exit_code}"

src/bin/app_totsugeki.rs

@@ -21,6 +21,13 @@ fn run() {
 	println!("!!!TOTSUGEKI!!!!");
 	let mut router = app::routing::Router::new();
 
+	//dbg!(&app::routing::PosVel::new(-17, 7, 2, 4).is_in_valid_area());
+
+	// dbg!(&router.get_next_move(-48, -23, 0, 0, 48, 23));  // cowday最初のターン
+	// dbg!(&router.get_next_move(-19, 3, 3, 6, 9, 17));  // cowday死ぬ直前 - 1
+	// return;
+	// dbg!(&router.get_next_move(-17, 7, 2, 4, 4, 17));  // cowday死ぬ直前
+
 	/*
 	dbg!(&router.get_next_move(1, 35, 0, 0, -100, -100));
 	return;
@@ -38,11 +45,11 @@ fn run() {
 	}
 	let player_key = std::env::args().nth(2).unwrap();
 
-	client.join(&player_key);
+  let resp = client.join(&player_key);
 
 	// TODO: sideによってトータル変える
 	let cool = 16;
-	let mut resp = client.start(448 - cool * 12 - 1 * 2, 0, cool, 1);
+	let mut resp = client.start(resp.info.ability.potential - cool * 12 - 1 * 2, 0, cool, 1);
 
 	let my_id = resp.state.ships.iter().find_map(|s| if s.role == resp.info.role { Some(s.id) } else { None }).unwrap();
 	let en_id = 1 - my_id;  // TODO: 分裂したらやばい・・・・・・しらない・・・・・・

src/bin/get_room.rs

@@ -0,0 +1,28 @@
+extern crate colored;
+
+use std::process::*;
+use std::io::prelude::*;
+use colored::*;
+use app::client::*;
+use app::parser::*;
+
+fn get_room(server_url: String) -> (String, String) {
+	let client = Client::new(server_url);
+	let e = get_list(&client.send("[1, 0]")).unwrap()[1].clone();
+	let e = get_list(&e).unwrap();
+	let a = get_list(&e[0]).unwrap();
+	let d = get_list(&e[1]).unwrap();
+	(a[1].to_string(), d[1].to_string())
+}
+
+fn main() {
+	let args: Vec<String> = std::env::args().collect();
+	let server_url = args[1].clone();
+	let client = Client::new(server_url);
+	let e = get_list(&client.send("[1, 0]")).unwrap()[1].clone();
+	let e = get_list(&e).unwrap();
+	let a = get_list(&e[0]).unwrap();
+	let d = get_list(&e[1]).unwrap();
+	println!("{}", a[1]);
+	println!("{}", d[1]);
+}

src/bin/tos1.rs

@@ -0,0 +1,111 @@
+use app::client::*;
+// use std;
+use std::convert::*;
+use rand::Rng;
+
+fn run() {
+	let mut rng = rand::thread_rng();
+	let server_url = std::env::args().nth(1).unwrap();
+	let mut client = Client::new(server_url);
+	if std::env::args().len() == 2 {
+		client.send("[1, 0]");
+		return;
+	}
+	let player_key = std::env::args().nth(2).unwrap();
+	let mut resp = client.join(&player_key);
+	let power = 32;
+	let cool = 0;
+	let life = 1;
+	resp = client.start(resp.info.ability.potential - power * 4 - cool * 12 - life * 2, power, cool, life);
+
+	// let mut dx: i32 = std::env::var("DX").unwrap().parse().unwrap();
+	// let dy: i32 = std::env::var("DY").unwrap().parse().unwrap();
+	let mut dx = 0;
+	let mut dy = 0;
+	while resp.stage != 2 {
+		let mut myship = None;
+		for ship in resp.state.ships.iter() {
+			if ship.role != resp.info.role {
+				continue;
+			}
+			myship = Some(ship.clone());
+		}
+		let myship = myship.unwrap();
+
+		let mut commands = vec![];
+
+		{
+			// anti gravity
+			let (x, y) = myship.pos;
+			// println!("{}, {}", x, y);
+			// assert_eq!(myship.v, (0, 0));
+			// println!("{:?}", myship.v);
+			let (gx, gy) = gravity(x, y);
+			// println!("{}, {}", gx, gy);
+			commands.push(
+				Command::Accelerate(myship.id, gravity(x, y))
+			);
+		}
+		
+		let shoot_now = myship.heat -myship.status.cool + 16 <= myship.max_heat;
+		if shoot_now {
+			let fix = resp.info.role;
+			// dx = rng.gen_range(0, 20) + fix;
+			dx = rng.gen_range(32, 96) + fix;
+			// dy = rng.gen_range(0, 20) + fix;
+			dy = 0;
+			let shoot_power = power;
+			commands.push(Command::Shoot(1, (myship.pos.0 + dx, myship.pos.1 + dy), shoot_power, None));
+		}
+
+		// !!!
+		resp = client.command(&commands);
+		// !!!
+
+		if shoot_now {
+			// println!("{}", resp);
+			println!("S H O O O O O O O T ! ! ! ! ! ! !");
+			for ship in resp.state.ships.iter() {
+				for cmd in ship.commands.iter() {
+					match cmd {
+						Command::Shoot(_, (x,y), p, Some((impact, four))) => {
+							println!("_, x, y, power, impact, four");
+							println!("[shoot], {}, {}, {}, {}, {}",
+								x - ship.pos.0,y - ship.pos.1, p, impact, four);
+						},
+						_=> {},
+					}
+				}
+			}
+		}
+	}
+}
+
+fn main() {
+	let _ = ::std::thread::Builder::new()
+		.name("run".to_string())
+		.stack_size(32 * 1024 * 1024)
+		.spawn(run)
+		.unwrap()
+		.join();
+}
+
+fn gravity(x: i32, y: i32) -> (i32, i32) {
+	(
+		if x.abs() >= y.abs() {
+			if x < 0 {
+				1
+			} else {
+				-1
+			}
+		} else { 0 },
+
+		if x.abs() <= y.abs() {
+			if y < 0 {
+				1
+			} else {
+				-1
+			}
+		} else { 0 },
+	)
+}