# data[].attributes.body
import numpy as np
import pandas as pd
import seaborn as sns
sns.set_style('whitegrid')
titanic = sns.load_dataset('titanic')
titanic.head()
titanic.describe()
titanic.dropna().describe()
titanic.var()
titanic.groupby('class').count()
sns.countplot(y='class', data=titanic);
sns.countplot(y='sex', data=titanic);
sns.countplot(y='alive', data=titanic);
sns.countplot(y='alone', data=titanic);
titanic.groupby('class').std()
titanic.groupby('class'['fare'].median()
titanic.query("alive == 'yes' ")
titanic.query("alive == 'yes' ").groupby('class').count()
titanic.groupby('class')['age'].describe
titanic.query("alive == 'yes'").groupby('class').describe()
titanic.groupby('sex')['age'].aggregate([min, np.median, max])
titanic.query("age > 30").groupby('class').median()
titanic.query("fare < 20").groupby('class').median()
titanic.groupby(['class', 'sex'])['age'].mean().unstack()
sns.catplot(x='sex', y='age',
            hue='class', kind='bar',
            data=titanic);
sns.catplot(x='who', y='age',
            hue='class', kind='bar',
            data=titanic);
titanic.groupby(['class', 'sex'])['fare'].mean().unstack()
titanic.groupby(['class', 'who'])['fare'].mean().unstack()
sns.catplot(x='sex', y='fare',
            hue='class', kind='bar',
            data=titanic);
sns.catplot(x='who', y='fare',
            hue='class', kind='bar',
            data=titanic);
titanic.groupby(['class', 'sex'])['survived'].mean().unstack()
titanic.pivot_table('survived', index='class', columns='who')
sns.catplot(x='class', y='survived',
            hue='sex', kind='bar',
            data=titanic);
sns.catplot(x='class', y='survived',
            hue='who', kind='bar',
            data=titanic);
age = pd.cut(titanic['age'], [0, 18, 40, 80])
titanic.pivot_table('survived', ['sex', age], 'class')
fare = pd.qcut(titanic['fare'], 3)
titanic.pivot_table('survived', ['who', age], [fare, 'class'])
titanic.pivot_table('survived', index='who', columns='class', margins=True)
sns.catplot(x='class', y='survived',
            col='who', kind='bar',
            data=titanic);
titanic.pivot_table('survived', index='deck', columns='class', margins=True)
sns.countplot(y='deck', data=titanic);
sns.countplot(y='deck', hue='class', data=titanic);
sns.catplot(x='survived', y='deck',
            hue='class', kind='bar',
            data=titanic);
titanic.pivot_table('survived', index='embark_town', columns='class', margins=True)
sns.countplot(y='embark_town', data=titanic);
sns.catplot(x='survived', y='embark_town',
            hue='class', kind='bar',
            data=titanic);
sns.catplot(x='sibsp', y='survived',
            kind='bar', data=titanic);
sns.catplot(x='parch', y='survived',
            kind='bar', data=titanic);
sns.catplot(x='alone', y='survived',
            kind='bar', data=titanic);

# data[].attributes.headline
웹해킹 올드 17번 이상엽

# data[].attributes.subject
웹해킹 올드 17번 이상엽

# data[].attributes.body
F12를 누르면 script 옆에 ...을 누르면 많은 값이 나온다. 그 숫자들을 다 계산하면 7809297.1이 나오는데 그 값은 파이썬에 넣으면 나온다. 7809297.1을 빈칸에 넣으면 풀린다.

# data[].attributes.body
import pygame
import sys
import random
import math


pygame.init()


screen_width = 1200
screen_height = 800
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Move Object with Arrow Keys and Avoid Obstacles")


BLACK = (0, 0, 0)
RED = (255, 0, 0)
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)


font = pygame.font.SysFont(None, 36)


object_size = 17
object_x = screen_width // 2 - object_size // 2
object_y = screen_height // 2 - object_size // 2
object_speed = 10


circle_radius = 350
circle_x = screen_width // 2
circle_y = screen_height // 2


obstacle_size = 8
obstacles = []


obstacle_timer = 0
obstacle_interval = 5000
random_obstacle_timer = 0
random_obstacle_interval = 600
start_time = pygame.time.get_ticks()

def is_within_circle(obj_x, obj_y, circle_x, circle_y, circle_radius, obj_size):

    obj_center_x = obj_x + obj_size / 2
    obj_center_y = obj_y + obj_size / 2


    distance = math.sqrt((obj_center_x - circle_x) ** 2 + (obj_center_y - circle_y) ** 2)


    return distance + obj_size / 2 <= circle_radius

def create_obstacle(obj_x, obj_y, angle=None):
    if angle is None:

        edges = ['left', 'right', 'top', 'bottom']
        edge = random.choice(edges)

        if edge == 'left':
            x = 0
            y = random.randint(0, screen_height)
        elif edge == 'right':
            x = screen_width
            y = random.randint(0, screen_height)
        elif edge == 'top':
            x = random.randint(0, screen_width)
            y = 0
        else:  # 'bottom'
            x = random.randint(0, screen_width)
            y = screen_height


        dx = obj_x + object_size / 2 - x
        dy = obj_y + object_size / 2 - y
    else:

        x = screen_width // 2 + circle_radius * math.cos(angle)
        y = screen_height // 2 + circle_radius * math.sin(angle)


        dx = obj_x + object_size / 2 - x
        dy = obj_y + object_size / 2 - y

    distance = math.sqrt(dx**2 + dy**2)
    dx /= distance
    dy /= distance

    speed = random.uniform(5, 10)

    return [x, y, dx, dy, speed]

def move_obstacle(obstacle):
    obstacle[0] += obstacle[2] * obstacle[4]
    obstacle[1] += obstacle[3] * obstacle[4]

def detect_collision(obj_x, obj_y, obj_size, obs_x, obs_y, obs_size):

    return (obj_x < obs_x + obs_size and
            obj_x + obj_size > obs_x and
            obj_y < obs_y + obs_size and
            obj_y + obj_size > obs_y)

def draw_arrow(screen, color, position, angle, size):
    x, y = position
    point1 = (x + size * math.cos(angle), y + size * math.sin(angle))
    point2 = (x + size * math.cos(angle + 2.5), y + size * math.sin(angle + 2.5))
    point3 = (x + size * math.cos(angle - 2.5), y + size * math.sin(angle - 2.5))
    pygame.draw.polygon(screen, color, [point1, point2, point3])


running = True
clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    new_x, new_y = object_x, object_y

    if keys[pygame.K_LEFT]:
        new_x -= object_speed
    if keys[pygame.K_RIGHT]:
        new_x += object_speed
    if keys[pygame.K_UP]:
        new_y -= object_speed
    if keys[pygame.K_DOWN]:
        new_y += object_speed


    if is_within_circle(new_x, new_y, circle_x, circle_y, circle_radius, object_size):
        object_x, object_y = new_x, new_y


    obstacle_timer += clock.get_time()
    if obstacle_timer >= obstacle_interval:
        for i in range(12):
            angle = math.radians(30 * i)
            new_obstacle = create_obstacle(object_x, object_y, angle)
            obstacles.append(new_obstacle)
        obstacle_timer = 0


    random_obstacle_timer += clock.get_time()
    if random_obstacle_timer >= random_obstacle_interval:
        new_obstacle = create_obstacle(object_x, object_y)
        obstacles.append(new_obstacle)
        random_obstacle_timer = 0


    for obstacle in obstacles:
        move_obstacle(obstacle)
        if detect_collision(object_x, object_y, object_size, obstacle[0], obstacle[1], obstacle_size):
            running = False


    elapsed_time = (pygame.time.get_ticks() - start_time) / 1000
    timer_text = font.render(f"Time: {elapsed_time:.2f} s", True, WHITE)


    screen.fill(BLACK)


    pygame.draw.circle(screen, WHITE, (circle_x, circle_y), circle_radius)


    pygame.draw.rect(screen, RED, (object_x, object_y, object_size, object_size))


    for obstacle in obstacles:
        angle = math.atan2(obstacle[3], obstacle[2])
        draw_arrow(screen, BLACK, (obstacle[0], obstacle[1]), angle, obstacle_size)


    screen.blit(timer_text, (screen_width - 200, 10))


    pygame.display.flip()


    clock.tick(30)

pygame.quit()
sys.exit()

# data[].attributes.body
import pygame
import math
import random

# Pygame 초기화
pygame.init()

# 화면 설정
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("죽림고수")

# 색상 정의
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)

# 폰트 설정
font = pygame.font.Font(None, 36)

# 플레이어 설정
player_size = 15
player_speed = 5

# 큰 원 설정
circle_radius = 300
circle_center = (WIDTH // 2, HEIGHT // 2)

# 화살 설정
arrow_width = 10
arrow_height = 5
arrow_speed = 4
arrows = []

# 화살 생성 주기
arrow_spawn_time = 1000  # 1초
last_arrow_spawn = pygame.time.get_ticks()

# 5초마다 생성되는 화살 개수
arrows_per_wave = 1
last_wave_time = pygame.time.get_ticks()

# 타이머 설정
timer_font = pygame.font.Font(None, 36)
timer_x = WIDTH - 200  # 타이머 위치 X좌표
timer_y = 20           # 타이머 위치 Y좌표
start_time = pygame.time.get_ticks()

# 게임 종료 여부
game_over = False
score_calculated = False  # 점수가 이미 계산되었는지 여부

def reset_game():
    global player_x, player_y, arrows, last_arrow_spawn, arrows_per_wave, last_wave_time, start_time, game_over, score_calculated
    player_x = WIDTH // 2
    player_y = HEIGHT // 2
    arrows = []
    last_arrow_spawn = pygame.time.get_ticks()
    arrows_per_wave = 1
    last_wave_time = pygame.time.get_ticks()
    start_time = pygame.time.get_ticks()
    game_over = False
    score_calculated = False

# 게임 초기화
reset_game()

def spawn_arrow():
    angle = random.uniform(0, 2 * math.pi)
    arrow_x = circle_center[0] + circle_radius * math.cos(angle)
    arrow_y = circle_center[1] + circle_radius * math.sin(angle)
    direction = math.atan2(player_y - arrow_y, player_x - arrow_x)
    arrows.append({'x': arrow_x, 'y': arrow_y, 'angle': direction})

def spawn_straight_arrows():
    base_x = 0  # 화살의 시작 X 좌표 (화면 왼쪽 가장자리)
    base_y = HEIGHT - arrow_height  # 원의 아래쪽 가장자리에서 시작
    for i in range(5):
        arrow_x = base_x + i * 50
        arrow_y = base_y
        direction = -math.pi / 2  # 위쪽으로 향함
        arrows.append({'x': arrow_x, 'y': arrow_y, 'angle': direction})

# 게임 루프
running = True
clock = pygame.time.Clock()

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_r and game_over:
                reset_game()

    if not game_over:
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            player_x -= player_speed
        if keys[pygame.K_RIGHT]:
            player_x += player_speed
        if keys[pygame.K_UP]:
            player_y -= player_speed
        if keys[pygame.K_DOWN]:
            player_y += player_speed

        # 플레이어가 큰 원 밖으로 나가지 않도록 제한
        half_player_size = player_size / 2
        corners = [
            (player_x - half_player_size, player_y - half_player_size),
            (player_x + half_player_size, player_y - half_player_size),
            (player_x - half_player_size, player_y + half_player_size),
            (player_x + half_player_size, player_y + half_player_size),
        ]

        for corner in corners:
            distance_from_center = math.hypot(corner[0] - circle_center[0], corner[1] - circle_center[1])
            if distance_from_center > circle_radius:
                angle = math.atan2(corner[1] - circle_center[1], corner[0] - circle_center[0])
                player_x = circle_center[0] + (circle_radius - half_player_size) * math.cos(angle)
                player_y = circle_center[1] + (circle_radius - half_player_size) * math.sin(angle)
                break

        # 5초마다 생성되는 화살 개수 증가
        current_time = pygame.time.get_ticks()
        elapsed_time = current_time - start_time
        if current_time - last_wave_time > 5000:  # 5초마다
            if elapsed_time < 15000:  # 15초 이후부터는 화살 개수 증가 중지
                arrows_per_wave += 1
            last_wave_time = current_time

        # 15초 이후부터 5초마다 사방에서 5개의 화살 생성
        if elapsed_time >= 15000 and (elapsed_time - 15000) % 5000 < 60:
            for _ in range(5):
                spawn_arrow()


        # 화살 생성
        if current_time - last_arrow_spawn > arrow_spawn_time and not game_over:
            for _ in range(arrows_per_wave):
                spawn_arrow()
            last_arrow_spawn = current_time

        # 화살 이동 및 원의 반대편 가장자리에 닿았는지 확인
        for arrow in arrows[:]:
            arrow['x'] += arrow_speed * math.cos(arrow['angle'])
            arrow['y'] += arrow_speed * math.sin(arrow['angle'])

            distance_from_center = math.hypot(arrow['x'] - circle_center[0], arrow['y'] - circle_center[1])
            if distance_from_center > circle_radius:
                arrows.remove(arrow)

        # 화살과 플레이어 충돌 검사
        player_rect = pygame.Rect(player_x - half_player_size, player_y - half_player_size, player_size, player_size)
        for arrow in arrows:
            arrow_rect = pygame.Rect(arrow['x'] - arrow_width / 2, arrow['y'] - arrow_height / 2, arrow_width, arrow_height)
            if player_rect.colliderect(arrow_rect):
                game_over = True  # 게임 종료
                if not score_calculated:
                    elapsed_time = pygame.time.get_ticks() - start_time  # 현재까지의 경과 시간 저장
                    score = int(elapsed_time / 10)  # 생존 시간 * 100
                    score_calculated = True
                break  # 충돌 발생 시 더 이상 화살 검사할 필요 없음

        # 타이머 업데이트
        if not game_over:
            elapsed_time = pygame.time.get_ticks() - start_time
            seconds = elapsed_time / 1000
            timer_text = timer_font.render(f"Time: {seconds:.2f}", True, WHITE)

    # 화면 그리기
    screen.fill(BLACK)  # 배경색을 검은색으로 설정
    pygame.draw.circle(screen, WHITE, circle_center, circle_radius)  # 원 안쪽을 하얀색으로 채움
    pygame.draw.circle(screen, WHITE, circle_center, circle_radius, 2)  # 흰색 외곽선
    player_rect = pygame.Rect(player_x - half_player_size, player_y - half_player_size, player_size, player_size)
    pygame.draw.rect(screen, BLACK, player_rect)
    for arrow in arrows:
        pygame.draw.rect(screen, RED, pygame.Rect(arrow['x'] - arrow_width / 2, arrow['y'] - arrow_height / 2, arrow_width, arrow_height))

    # 타이머
    if not game_over:
        screen.blit(timer_text, (timer_x, timer_y))

    if game_over:
        game_over_text = font.render(f"Game Over - Score: {score}", True, BLACK)
        screen.blit(game_over_text, (WIDTH // 2 - 150, HEIGHT // 2 - 18))
        reset_text = font.render("Press R to Restart", True, BLACK)
        screen.blit(reset_text, (WIDTH // 2 - 150, HEIGHT // 2 + 18))

    pygame.display.flip()
    clock.tick(60)

pygame.quit()

# data[].attributes.body
html 코드를 사용하면서 팀원과 서로의 코딩 역량을

기르기 위해서 서로의 의견을 주고 받으면서 진행했다

# data[].attributes.body
죽림고수 게임을 만들며 팀원 각각의 역량을 올렸으며 다음 시간까지 서로의 작업물을 주고 받으며 완벽하게 마무리할 수 있을 것으로 예상된다

# data[].attributes.body
배터리 홀더 2개

# data[].attributes.headline
웹해킹 올드 23번 김경록

# data[].attributes.subject
웹해킹 올드 23번 김경록

# data[].attributes.body
1. 영어문자를 연속해서 입력하면 출력이 되지 않고 no back으로 뜸

2. 공백을 사용해서 출력해야한다

3. 영어문자사이에 null값을 집어넣어야하는데 url인코딩 값인 %00을 넣어서 출력하면된다

# data[].attributes.body
1. If 문에 do it 이라는 주석이 있으니 조건문을 실행시켜야한다

2. 키보드 입력 값 100,97,11,115,124 중 하나이면 조건문을 통과 시킬 수 있다

3. 아스키 코드 값을 참고하여 100,97,11,115의 값을 구하면 각각 d a w s이다

4. 124가 의미하는 값은 \라는 키보드 값을 쉬프트를 누른 상태로 누르면 |가 출력된다

5. |를 키입력하면 문제가 풀린다

# data[].attributes.body
Magica Voxel을 이용해 레이싱 카를 디자인했다.

# data[].attributes.headline
웹해킹올드10번(고재현)

# data[].attributes.subject
웹해킹올드10번(고재현)

# data[].attributes.body
1. F12를 눌러 Html창을 본다.

2. <td>를 눌러 o의 값을 변경하는 부분 left 위치를 찾는다.

3. 0에 있는 o의 위치를 값을 1599로 바꿔 위치를 1599로 바꾼다

4. o를 한 번 더 클릭하여 위치를 1 이동시켜 1600에 놓으면 문제가 풀린다.

# data[].attributes.body
html에서 여러가지 코드를 사용해 사이트를 수정하고 편집 할 수 있었다

h1 코드는 제목의 글씨크기를 키울 수 있고

strong 코드는 글씨의 색을 더 진하게 할 수 있다또한 글자속에 링크를 추가해 클릭하면 링크로 이동이 가능한 a 코드가 있었고

이 a 코드가 사용된 글자 위에 마우스 포인터를 올리면 내가 작성한 정보를 나타나게 해주는 target blank title 코드까지 배웠다

# data[].attributes.body
플래시 게임 '죽림고수'를 모티브로 vs코드를 이용하여 팀원 개개인이 게임을 직접 만들어 보는 동시에 서로가 서로에게 게임 제작 관련 피드백을 해주면서 팀원 모두의 코딩 실력 성장을 노려 볼 수 있다.

1회차 : 주제 선정 및 계획 세우기/기본 코딩 학습

2-3회차 : 개발 (각자 개발 + 한 주제로 각자 게임을 개발하여 개인의 실력 성장 및 협력)

4회차 : 최종 코드 수정 및 마무리, 발표

# data[].attributes.attachment_link.title
죽림고수 - 추억의 한게임플래시

# data[].attributes.attachment_link.description
대나무숲에서 벌어지는 최대의 결전! 죽림고수 플래시게임입니다 조작 방법 키보드 ← ↑ ↓ → 제작 정보 제작자 한게임플래시 배급 한게임플래시

# data[].attributes.body
solve(18)를 하는 조건에 id가 "admin"이면 된다고 적혀있다.

id="admin"라는 조건을 적으면 문제가 풀리게 된다.

답: 0%09or%09id="admin"

# data[].attributes.body
View-source를 클릭하면 user_lv 가 3초과 4이상이라고 했기 때문에 F12를 눌러서 application에서 cookies를 눌러서 user_lv의 값을 1에서 3.5로 변경한다 그리고 다시 old 1번을 들러가면 문제가 풀린다

# data[].attributes.body
5/8 발표 생략

# data[].attributes.headline
웹해킹 14번 (고재현)

# data[].attributes.subject
웹해킹 14번 (고재현)

# data[].attributes.body
풀이

ctrl+u를 눌러 소스코드를 확인해보면

document.URL이 적혀있다.

이는 문서 주소를 변환하는 성질이 있다.

해석하자면 ckeck 버튼을 누르면 입력한 수

(.kr의 위치)에 30이 곱해져 저장되고, 그게 ul값과 일치하면 문제가 풀리는 것이다

pw.input_pwd.value (입력하는 창)에

.kr의 위치(글자수 위치 18번째) 18x30인 540을 입력하면 if 조건문을 만족하여 해결된다.

# data[].attributes.headline
웹 해킹 올드 26번 (김경록)

# data[].attributes.subject
웹 해킹 올드 26번 (김경록)

# data[].attributes.body
1. 소스를 확인합니다.

2. Id에 admin을 입력합니다

3. Admin은 url인코딩표로 풀면 %61%64%6D%69%6E로 입력

4. 이중잠금장치이기 때문에 %61%64%6D%69%6E를 한번더 변환하여 입력한다. (자동변환프로그램사용)

5. 해결~~

# data[].attributes.body
<20404 고재현>

20417 이상엽

20418 이어진

20601 김경록

20509 배상우

# data[].attributes.body
Arduino를 사용하여 초음파 센서를 통해 물체까지의 거리를 측정하고, 서브 모터를 사용하여 센서의 시야를 회전시키는 코드

// Includes the Servo library

#include <Servo.h>.

// Defines Tirg and Echo pins of the Ultrasonic Sensor

const int trigPin = 10;

const int echoPin = 11;

// Variables for the duration and the distance

long duration;

int distance;

Servo myServo; // Creates a servo object for controlling the servo motor

void setup() {

pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output

pinMode(echoPin, INPUT); // Sets the echoPin as an Input

Serial.begin(9600);

myServo.attach(12); // Defines on which pin is the servo motor attached

}

void loop() {

// rotates the servo motor from 15 to 165 degrees

for(int i=15;i<=165;i++){

myServo.write(i);

delay(30);

distance = calculateDistance();// Calls a function for calculating the distance measured by the Ultrasonic sensor for each degree

Serial.print(i); // Sends the current degree into the Serial Port

Serial.print(","); // Sends addition character right next to the previous value needed later in the Processing IDE for indexing

Serial.print(distance); // Sends the distance value into the Serial Port

Serial.print("."); // Sends addition character right next to the previous value needed later in the Processing IDE for indexing

}

// Repeats the previous lines from 165 to 15 degrees

for(int i=165;i>15;i--){

myServo.write(i);

delay(30);

distance = calculateDistance();

Serial.print(i);

Serial.print(",");

Serial.print(distance);

Serial.print(".");

}

}

// Function for calculating the distance measured by the Ultrasonic sensor

int calculateDistance(){

digitalWrite(trigPin, LOW);

delayMicroseconds(2);

// Sets the trigPin on HIGH state for 10 micro seconds

digitalWrite(trigPin, HIGH);

delayMicroseconds(10);

digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH); // Reads the echoPin, returns the sound wave travel time in microseconds

distance= duration*0.034/2;

return distance;

}

시각적인 레이더 효과를 시뮬레이션하는 것으로, 아두이노로부터 받은 데이터를 시각적으로 표현하는 코드

import processing.serial.*; // imports library for serial communication

import java.awt.event.KeyEvent; // imports library for reading the data from the serial port

import java.io.IOException;

Serial myPort; // defines Object Serial

// defubes variables

String angle="";

String distance="";

String data="";

String noObject;

float pixsDistance;

int iAngle, iDistance;

int index1=0;

int index2=0;

PFont orcFont;

void setup() {

size (1200, 700); // ***CHANGE THIS TO YOUR SCREEN RESOLUTION***

smooth();

myPort = new Serial(this,"COM5", 9600); // starts the serial communication

myPort.bufferUntil('.'); // reads the data from the serial port up to the character '.'. So actually it reads this: angle,distance.

}

void draw() {

fill(98,245,31);

// simulating motion blur and slow fade of the moving line

noStroke();

fill(0,4);

rect(0, 0, width, height-height*0.065);

fill(98,245,31); // green color

// calls the functions for drawing the radar

drawRadar();

drawLine();

drawObject();

drawText();

}

void serialEvent (Serial myPort) { // starts reading data from the Serial Port

// reads the data from the Serial Port up to the character '.' and puts it into the String variable "data".

data = myPort.readStringUntil('.');

data = data.substring(0,data.length()-1);

index1 = data.indexOf(","); // find the character ',' and puts it into the variable "index1"

angle= data.substring(0, index1); // read the data from position "0" to position of the variable index1 or thats the value of the angle the Arduino Board sent into the Serial Port

distance= data.substring(index1+1, data.length()); // read the data from position "index1" to the end of the data pr thats the value of the distance

// converts the String variables into Integer

iAngle = int(angle);

iDistance = int(distance);

}

void drawRadar() {

pushMatrix();

translate(width/2,height-height*0.074); // moves the starting coordinats to new location

noFill();

strokeWeight(2);

stroke(98,245,31);

// draws the arc lines

arc(0,0,(width-width*0.0625),(width-width*0.0625),PI,TWO_PI);

arc(0,0,(width-width*0.27),(width-width*0.27),PI,TWO_PI);

arc(0,0,(width-width*0.479),(width-width*0.479),PI,TWO_PI);

arc(0,0,(width-width*0.687),(width-width*0.687),PI,TWO_PI);

// draws the angle lines

line(-width/2,0,width/2,0);

line(0,0,(-width/2)*cos(radians(30)),(-width/2)*sin(radians(30)));

line(0,0,(-width/2)*cos(radians(60)),(-width/2)*sin(radians(60)));

line(0,0,(-width/2)*cos(radians(90)),(-width/2)*sin(radians(90)));

line(0,0,(-width/2)*cos(radians(120)),(-width/2)*sin(radians(120)));

line(0,0,(-width/2)*cos(radians(150)),(-width/2)*sin(radians(150)));

line((-width/2)*cos(radians(30)),0,width/2,0);

popMatrix();

}

void drawObject() {

pushMatrix();

translate(width/2,height-height*0.074); // moves the starting coordinats to new location

strokeWeight(9);

stroke(255,10,10); // red color

pixsDistance = iDistance*((height-height*0.1666)*0.025); // covers the distance from the sensor from cm to pixels

// limiting the range to 40 cms

if(iDistance<40){

// draws the object according to the angle and the distance

line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),(width-width*0.505)*cos(radians(iAngle)),-(width-width*0.505)*sin(radians(iAngle)));

}

popMatrix();

}

void drawLine() {

pushMatrix();

strokeWeight(9);

stroke(30,250,60);

translate(width/2,height-height*0.074); // moves the starting coordinats to new location

line(0,0,(height-height*0.12)*cos(radians(iAngle)),-(height-height*0.12)*sin(radians(iAngle))); // draws the line according to the angle

popMatrix();

}

void drawText() { // draws the texts on the screen

pushMatrix();

if(iDistance>40) {

noObject = "Out of Range";

}

else {

noObject = "In Range";

}

fill(0,0,0);

noStroke();

rect(0, height-height*0.0648, width, height);

fill(98,245,31);

textSize(25);

text("10cm",width-width*0.3854,height-height*0.0833);

text("20cm",width-width*0.281,height-height*0.0833);

text("30cm",width-width*0.177,height-height*0.0833);

text("40cm",width-width*0.0729,height-height*0.0833);

textSize(40);

text("Indian Lifehacker ", width-width*0.875, height-height*0.0277);

text("Angle: " + iAngle +" ", width-width*0.48, height-height*0.0277);

text("Distance: ", width-width*0.26, height-height*0.0277);

if(iDistance<40) {

text(" " + iDistance +" cm", width-width*0.225, height-height*0.0277);

}

textSize(25);

fill(98,245,60);

translate((width-width*0.4994)+width/2*cos(radians(30)),(height-height*0.0907)-width/2*sin(radians(30)));

rotate(-radians(-60));

text("30 ",0,0);

resetMatrix();

translate((width-width*0.503)+width/2*cos(radians(60)),(height-height*0.0888)-width/2*sin(radians(60)));

rotate(-radians(-30));

text("60 ",0,0);

resetMatrix();

translate((width-width*0.507)+width/2*cos(radians(90)),(height-height*0.0833)-width/2*sin(radians(90)));

rotate(radians(0));

text("90 ",0,0);

resetMatrix();

translate(width-width*0.513+width/2*cos(radians(120)),(height-height*0.07129)-width/2*sin(radians(120)));

rotate(radians(-30));

text("120 ",0,0);

resetMatrix();

translate((width-width*0.5104)+width/2*cos(radians(150)),(height-height*0.0574)-width/2*sin(radians(150)));

rotate(radians(-60));

text("150 ",0,0);

popMatrix();

}

# data[].attributes.attachment_link.title
How to Make a Radar with Arduino |  Arduino Project | Indian LifeHacker

# data[].attributes.body
+글루건

# data[].attributes.attachment_link.readable_text
1. 개인정보의 수집 방법

판매 상품의 배송을 위해 개인정보를 (주)지마켓으로부터 제공받습니다.

2. 이용자 개인정보의 수집 목적, 항목

수집/이용 목적: 상품 및 경품(서비스) 배송(전송), 제품 설치, 반품, 환불, 고객상담 등
정보통신 서비스제공 계약 및 전자상거래(통신판매)계약의 이행을 위해 필요한 업무의 처리

수집하는 항목:
(필수) (주)지마켓으로부터 제공받은 ID, 성명, 전화번호, 휴대폰번호, 배송지 주소
(선택) (주)지마켓으로부터 제공받은

3. 이용자 개인정보의 보유 : 이용기간 및 파기

이용자의 개인정보는 원칙적으로 보유기간이 경과하거나 이용목적이 달성된 경우에는
재생 불가능한 방법으로 지체 없이 파기합니다. (단, 법령 등에 의해 보관해야 하는 경우에는
해당기간 동안 보관합니다.)

4. 이용자의 권리와 행사방법

이용자는 언제든지 개인정보 수집·이용·제공 등의 동의를 철회할 수 있으며, 자신의
개인정보에 대해 열람·제공·정정을 요청할 수 있습니다. 개인정보에 대한 요청사항이
있으신 경우, 아래의 개인정보 관리책임자에게 이메일 또는 전화로 연락하시면 지체없이
조치하겠습니다.

5. 개인정보 자동 수집 장치의 설치·운영 및 거부에 관한 사항

개별 미니샵/스토어에서는 개인정보 자동 수집 장치를 설치 및 운영하지 않습니다.

6. 개인정보 제3자 제공

개별 미니샵/스토어에서는 개인정보를 제3자에게 제공하지 않습니다.

7. 개인정보의 처리위탁

8. 개인정보 보호책임자

개인정보보호 관련 민원은 아래의 개인정보 보호책임자에게 신고하여 주시기 바랍니다. 담당자 : E-mail :

본 '개인정보 처리방침'은 최신의 상태로 관리되고 있습니다.
시행일

# data[].attributes.body
<20414 손강호>

# data[].attributes.body
https://webhacking.kr/

# data[].attributes.body
<10409 신지후>

10604 노윤성

10720 강하은

10310 임지원

10312 정류현

10517 강현희

# data[].attributes.body
<20522 김은서>

20506 박성우

20518 김태희
20406 김건우
10904 김정우
10304 박찬용
10316 권나연

# data[].attributes.body
게임 종류 : 레이싱

게임 설명 : 유니티를 이용한 레이싱 게임

계획 : 1주 =>유니티 언어에 대한 기초 습득 및 활용

2주 =>레이싱 카 만들기(unity)

3주 =>레이싱 맵 만들기(unity)

4주 =>레이싱 게임을 실행 시키기 위한 코딩 작성(C#)

# data[].attributes.body
<10807 문희성>

10803 김승환

10127 이서진

# data[].attributes.body
<20512 이동주>

20407 김민성

20503 김지호

20513 이주혁

20515 조주영

10104 김은호

10805 김진현

10203 김건우

# data[].attributes.headline
웹해킹 올드 15번 (이상엽)

# data[].attributes.subject
웹해킹 올드 15번 (이상엽)

# data[].attributes.body
구글 설정에서 자바스크립트 허용을 멈추고 F12를 누르면 소스 코드가 나온다. 그 상태에서 url에 getFlag를 넣어주면 풀린다.