00:--
Initial sketch of the thought on my notebook ( pretty chaotic at first )
00:--
After few iterations – a bit more refined version of the concept
// Implementing the Logic
01:35:
Setup the new development environment (...obligatory “Hello world!”)
05:16:
Planned out first draft product models and model relationships
10:38: Setup Motion model
11:32: Setup Motion controller and routes
12:29: Created new/create/edit/update/destroy view templates for motions
18:22: Created Assertion Relations model to establish parent - counter relationship
24:53: Created assertion profile page
29:51: Imbedded counter assertions under assertion page
36:41: Created embedded support inputs list on assertion page
38:40: Implemented support rating system to assertion model to aggregate and calculate support inputs
39:27: Implemented support rating system to motion model
40:10: Implemented support / counter count and total rating system to motion model and views
// Defining & Applying the Aesthetic
48:37: Brainstormed the aesthetic and UX direction of the product
49:36: Curated typography and color palette
50:20:
Sketched the layout for motion page
52:12:
Sketched the layout for assertion page
60:36: Created the layout for motions page and implemented color sliding scale to correspond with support level
64:10: Designed and coded layout for supporting & counter assertions
66:07: Updated support / counter assertion list layout to mute disregarded assertions
69:33: Created the layout for assertion main content
70:05: Created layout for counter assertion to assertion section
71:54: Created the layout for assertion parent heading
72:58: Created the layout for evidence list
77:39: Created the layout for support input
79:18: Created the layout for support input list
81:25: Created layout for support input cards
83:19: Designed user page
84:27: Created the layout for user ID card
88:26: Created the layout for motions index page
89:04: Divided motions page into two separate parts
[ ... tied up loose ends ... ]
99:59: Deployed the app in production
Check out the pre-alpha demo of TRUEST.
Link to the FULL devlog of the week.
If you have any feedback or inquiries please reach out to [email protected]!
I’ve always been deeply frustrated about the current online environment for discussing important matters and finding out truth about what’s going on around the world. Online comment section is synonymous with chaos and vitriol and our generation is quickly losing confidence in large media outlets. I find that fact really unfortunate because I believe the internet is one of the most powerful promoter of democracy and freedom of information.
That is why I decided to build TRUEST. Where people can find what is the objective truth. ...Or something closest to that – collective consensus based on empirical evidence. Following is the devlog of the past week where I put 100 hours into creating the first version of this platform.
Soon I’ll be posting pictures that goes along with the log as well. Please feel free to reach out if you have any questions.
TRUEST
Total Time: 100:00
Nov 30, 2015, 3:16 PM
00:00: Project started
00:20: Updated Ruby & Ruby on Rails Versions
00:56: Setup a new development environment with a set of new tools [Atom text editor, iTerm2 command line tool]
01:25: Setup the project
01:35: Hello world!
02:03: Setup Heroku and deployed the initial state app
02:43: Sketched out general layout for the initial pages
03:25: Learned the basics of Rspec
04:14: Reviewed the fundamentals of Behavior Driven Development & set up BDD stack
04:33: Wrote the first spec
05:16: Planned out first draft product models and model relationships
05:47: Researched the ways to effectively implement voting system in Rails
06:21: Expanded first draft product model to include two-part rating system
06:48: Converted product model sketch into a database models
07:21: Created the user model and authentication system
07:56: Created signup/login/logout views
08:26: Wrote user model spec tests for validation
09:09: Learned further about RSpec & Shoulda-matcher gem and expanded user model spect tests
09:45: Created user edit/update page
10:38: Setup Motion model
11:32: Setup Motion controller and routes
12:29: Created new/create/edit/update/destroy view templates for motions
12:58: Established relationship between user - motions controllers & models
13:19: Day 2
13:51: Created database seed for development and debugging
14:20: Updated the motion views to reflect relationships with the user model
14:44: Deployed the app in production
15:32: Sketched out Support Assertion & Counter Assertion models
16:28: Researched different methods and frameworks for implementing tree structure in Rails
17:20: Set up Assertion model and the related database
18:22: Created Assertion Relations model to establish parent - counter relationship
19:04: Added model validations to Assertion
20:11: Revised self referential model to have has-one & has-many relationship
20:42: Created Assertion controller
22:13: Revised and experimented with has-one & has-many relationship
22:49: Created new assertion page
23:04: Created edit assertion page
23:44: Scripted instance method to motion model to divided supporting and counter assertions
24:28: Created embed supporting/counter assertion views in motion view
24:53: Created assertion profile page
25:16: Cleanup views and links across the app
25:39: Sketched out and set up Evidence model
26:24: Learned about accepts_nested_attributes_for feature and how to implement nested forms for Assertion & Evidence
27:44: Implemented nested attributes feature to embed Evidence model within Assertion
28:19: Updated assertion page to list embedded list of evidences
28:54: Updated nested model to automatically serve up 5 fields for evidences & set up validations
29:07: Day 3
29:51: Imbedded counter assertions under assertion page
30:25: Fixed a bug where form resubmission lost http parameters
30:53: Created database seed for assertions & evidences
31:23: Expanded the database seed with the use of Faker gem
32:25: Sketched out SupportInput model
33:09: Set up SupportInput model
33:34: Researched different voting methods and mechanics
34:06: Decided simple yes/no choice would be the most intuitive solution yet provide enough information when aggregated
34:43: Created support input model validations
35:26: Created support inputs controller
36:13: Created embedded support input form on assertion page
36:41: Created embedded support inputs list on assertion page
37:35: Addressed logistical issues and added additional validations for support inputs
38:01: Expanded database seed to generate support inputs
38:40: Implemented support rating system to assertion model to aggregate and calculate support inputs
38:54: Implemented support rating to assertion view
39:27: Implemented support rating system to motion model
40:10: Implemented support / counter count and total rating system to motion model and views
40:34: Implemented participation minimum threshold for motion model
40:52: Implemented minimum threshold for motion views
41:44: Refactored views to be more modular
42:06: Day 4
42:43: Created assertion counter system and updated motion support rating system to reject countered assertions
43:39: Created column in database to store support count and implemented count increment / decrement system in order to optimize performance
44:22: Added username to user model
45:31: Implemented username validation and automatic default username generation feature
46:25: Learned about implementations regex and how to reserve certain words for internal use
47:19: Completed first draft minimum viable product
48:37: Brainstormed the aesthetic and UX direction of the product
49:36: Curated typography and color palette
50:20: Sketched the layout for motion page
51:32: Reviewed and researched web design principles
52:12: Sketched the layout for assertion page
52:30: Setup fonts in asset pipeline
53:11: Learned about HAML markup language to clean up views
53:25: Also learned about Slim template language
53:49: Converted first view over to Slim language syntax
54:59: Designed and coded the layout for site header
56:23: Designed and coded the product logo and refactored the stylesheet to prepare for mobile implementation
56:56: Created the preliminary layout for the welcome page
58:18: Day 5
60:36: Created the layout for motions page and implemented color sliding scale to correspond with support level
61:47: Created the layout for authorship and implemented custom date format method
64:10: Designed and coded layout for supporting & counter assertions
65:29: Implemented support based sorting system
66:07: Updated support / counter assertion list layout to mute disregarded assertions
66:57: Created button layouts and added new assertion button to motion page
67:31: Added edit / delete motion buttons
68:06: Reviewed and completed layouts for motion page
68:57: Created the layout for assertion header
69:33: Created the layout for assertion main content
70:05: Created layout for counter assertion to assertion section
71:54: Created the layout for assertion parent heading
72:24: Added fade in and transition animations
72:58: Created the layout for evidence list
72:58: Day 6
73:29: Configured paragraph typography
73:58: Added new assertion button to assertion page
74:37: Created half section division for assertion page
75:32: Learned how to create custom layouts for form items
76:23: Created custom radio buttons for support inputs
77:39: Created the layout for support input text area
77:54: Added support input submit button
78:10: Created the layout for error messages
79:18: Created the layout for support input list
81:25: Created layout for support input cards
82:30: Added additional sorting system and validations for support inputs
83:19: Designed user page
84:27: Created the layout for user ID card
85:07: Completed the first draft layout for user page
86:06: Updated user page & assertion page & motion page to be responsive for mobile devices
87:12: Created the functions to sort motions by date and total rating
88:26: Created the layout for motions index page
89:04: Divided motions page into two separate parts
89:55: Day 7
90:06: Added add new motion button to motion index page
90:34: Removed all content creation links for non-logged in users
90:58: Implemented color coded layout for all motion rating markers
91:31: Implemented highlights to navigation bars when motion or profile picture is toggled
93:09: Created the layout for new motion page
93:40: Fixed layout issues from browser default stylings
95:30: Created the layout for new assertion page
96:14: Embedded evidences form within new assertion page
96:57: Created the layout for edit motion page
98:01: Created the layout for signup page
98:30: Created the layout for edit user page
98:59: Created the layout for login page
99:19: Created the layout for edit assertion page
99:50: Updated error messages to be human friendly
99:59: Deployed the app in production
100:00: Created TRUEST MVP! ( minimum viable product )
After my preliminary version of ruby on rails social network was deployed on the web, I quickly realized that, to create an application that people would want to use it is absolutely necessary to create a mobile application for it as well.
So I dedicated the first 3 weeks of August to learn Objective-C & Swift (Apple’s new programming language) and develop a fully functional mobile application.
This began as a way to develop the mobile app for my social networking site, but it happened to take a slightly different turn.
Here is a quick (-ish) summary of what happened:
The First Week
I spent all of my time taking a Objective-C Course from Teamtreehouse.com and built 6 demo application including one I’ve designed.
- In that week, I learned fundamentals of Objective-C & iOS (Cocoa Touch) framework, built basic snapchat-type app, third-party Instagram app, and designed & built sort-of-finished social rock paper scissors app.
... my first super basic iOS app.
The Second Week
I first took the Swift course from the teamtreehose.com. After completion I was quite dissatisfied the depth & coverage of the course, so I decided to get right to the official Swift Programming Language book by Apple.
- After completing the book, I was ready to start developing my first prototype app in Swift. But I wasn’t sure what I was going to build before fully jumping into building the app for my social networking site. I immediately started thinking about what I would want to use. So I decided to build an app to help me with the very process that I was partaking in – learning new things and documenting my progress.
Up to this point, I had been using several different tools to help me organize my learning & documentation process – such as todo-lists, timers, notepads for writing things down... etc. I tried using several apps and web extensions in attempt to streamline my process, and ended using bunch of separate tools –chrome timer extension, apple stock timer & note pad, extra notepad file in my coding projects, and others. It was only natural that I begin the development of Point A – the tool to document, track, and share my progress.
For the last two days of second week I built a working prototype of the the app. I built a basic app with timer-notepad integration. It was what I was doing with different tools, just put into one place.
The conceptual design & initial implementation of the app
The Third Week
After building the first functional prototype of Point A I didn’t want this project to cease as simply as a prototype. I decided to make Point A into a full fledged app made available to everyone via the App Store.
This last week I’ve implemented:
- Notes export feature
- Notes sort-by-timespan feature
- Project list page & ability to create multiple objects
- Project analysis & graphs
- App settings ( Auto-pause feature & Idle-timer disable feature )
- Swipe navigation & custom transitions
& created / gathered all the data for app store submission
Screenshots of Point A - the Finished Product
Point A is currently in a review process in the app store. If you are interested in the details of the process, below is the complete notes from the third week documented & exported via Point A app.
Also, if you have any questions about learning process of Objective-C, Swift, deploying to the app store, Point A app, or whatever – please feel free to contact me anytime. I can be reached at [email protected] or [email protected]
Point A: Week 2
Total Time: 96:37
Aug 24, 2015, 7:55 AM
00:00: Begun update of Point A
00:39: Designed analysis page
01:23: Created preliminary layout for project list view
01:41: Saved color pallets
02:29: Learned how to create custom segues
03:30: Implemented segues for main view to project list view
04:07: wired project database for project list view
04:44: Created pause indicator
05:05: Added back button for project list view
05:59: Created layout for project add function
06:54: Added add-project functionality
07:22: Implement auto save feature
08:09: Added text field delegate & keyboard release functionality
08:48: Implemented switch-project functionality
09:32: Created projects delete functionality
09:54: Coded security measures to insure safe project deletion
10:29: Added alert messages
10:49: Implemented notes delete functionality
11:05: Applied alert message styling
11:19: Applied minor styling updates
11:37: Coded sort-by-last-update functionality for project list
12:25: Day 2
13:07: Configured layout for notes list view
13:57: Set up segue from embedded notes table to notes list view
14:30: wired database to note list view
15:33: Transformed header view into a custom navigation bar
16:06: Created custom navigation bar for project list view as well
16:52: Learned how to create files from iOS app
17:25: Setup the interface for exporting notes
18:16: Learned about UIActivityView Controller
18:53: Implemented UIActivityView Controller for exporting notes
19:42: Implemented formatting system to present all notes for email exports
20:00: Applied reverse sorting order to export format for readability
20:44: Applied new layout for status bar and note view
21:27: Set up the layout for segmented control
22:25: Implemented timespan filter for notes list view
23:07: Implemented sort-by desc / asc functionality for notes list view
24:25: Implemented export text customization functionality
24:57: Day 3
25:30: Updated layout for notes list view
26:19: Learned how to make charts & graphs in iOS framework
27:00: Set up preliminary layout for progress view
27:45: Designed preliminary version of charts & objectives table
28:19: Set up segue for main view - progress view
28:43: Redesigned progress view as overview view
29:21: Created layout for info section of overview view
30:02: Wired data to overview view
30:37: Scripted function for calculating day count between two dates
31:01: Starting a practice project for creating & drawing graph charts in iOS
31:26: First lines of graph rendered using custom UIView
32:41: Learned how to draw custom graphs using custom UIViews
33:14: Learned how to use IBInspectible to customize Interface Builder editor
35:08: Created the layout for the new GraphView
36:00: Day 4
36:50: Added selection point indicator for overview graph
37:20: Incorporated tuples to bundle graph data & format together
37:57: Connected project data to overview graph
38:29: Learned about NSCalendar & how to calculate dates
39:08: Restructured overview view : grouped segmented control with overview graph
40:01: Created TimedData struct to organize data filtered by days, weeks, or months
40:27: Coded function to calculate total note count & total time based on given timespan
41:11: Implemented aforementioned data parsing for daily-breakdown
41:36: Implemented data parsing for weekly-breakdown
42:14: Implemented data parsing for monthly-breakdown
42:37: Wired data parsing functions to segmented control
43:33: Passed parsed data to the graph
43:56: First dynamic graph rendered with parsed data
44:46: Set up axillary outlets for graph view
45:30: Wired data to axillary outlets for graph view
46:24: Learned how to implement gesture recognizers
46:54: Implemented tap gesture recognizer & linked it to graph view and database
47:39: Implemented alternate graph showing total number of notes
48:43: Day 5
49:27: Set up settings view, controller, and segue between overview - settings
50:33: Created the preliminary layout for settings page
50:58: Curated collection quotes for settings page
51:19: Set up the view & layout for the quote section
51:49: Set up data model for collection quotes
52:20: Implemented function to randomly display a quote in settings page
52:58: Learned about NSUserDefaults & how to implement user settings function
53:33: Implemented user settings function
54:14: Configured style for settings table cells
54:45: Setup segues & view controllers for each setting menus
55:22: Learned how to use Visual Effects view for blur effect
55:49: Setup table view for FAQ page
56:21: Format the cells for FAQ page
56:58: Redesigned FAQ & About page for better navigation between pages
57:26: Completed the layout for the FAQ page
57:47: Wired navigation controls for FAQ page
58:17: Wired navigation controls for about page
58:33: Learned about different options for implementing support email feature
59:17: Implemented support email feature
59:37: Implemented auto pause setting feature to the app
60:15: Implemented never idle timer disable feature to the app
60:24: Updated graph view to use proper suffix to reflect plurality
61:06: Wrote the contents for the FAQ page
61:32: Updated the FAQ page with new content
62:27: Learned about in-app-purchases and official guidelines
63:18: Day 6 ( ~ 7 )
64:01: Created contribution / support page
65:23: Researched & enrolled in Apple Developer Program
65:42: Registered a new app ID
66:14: Tested the app physically on iPhone 6
66:52: Updated layouts based on observations from physical testing
67:21: Fixed a bug where project list is not updated when you first launch the app
68:11: Updated auto pause setting for app wide use using NSNotification Center
68:49: Implemented initial note creation function for newly created projects
69:40: Implemented preliminary layout for contribute page
70:00: Wired segue from settings page to contribute page
70:36: Implemented visual effects view (blur background) to contribute page
71:02: Completed the layout for contribute page
71:27: Setup view controller for contribute page
72:15: Updated graph view to have minimum ceiling value to more naturally progress
73:13: Learned how to implement 'share this app' link
73:26: Decided to hide contribute button until app is released
74:13: Reviewed Official App Store Review Guidlines
74:39: Reviewed how to make custom segues
75:26: Implemented custom segues for overview & project list views
76:20: Implemented custom segues for settings page and its sub views
76:44: Learned how to implement unwind segues
77:15: Implemented unwind segues for overview & project list view
77:44: Implemented unwind segues for settings page & sub views
78:28: Updated navigation control items to better reflect the new segues
79:13: Updated layout styles for the app to create unity in design
79:30: Smoothed out some buggy areas
79:59: Fixed more bugs & inconsistencies
80:43: Implemented swipe gesture recognition & swipe navigation for the main view
81:21: Implemented swipe gesture control for settings page
83:32: Found an extremely pesky bug with the custom transition.... for some reason the background view in deep layer was glitching & showing up at random times. "Fixed it" by changing its color
84:14: Took screenshots for app store submission
84:48: Created layered screenshot images for all iPhone devices
85:40: Read apple's guide on how to distribute/manage apps
86:36: Created code signature & linked my app to my dev account
87:18: Fixed a critical bug where settings table selection was duplicated on double click
87:59: Test the app & implemented minor bug / layout fixes
88:51: Wrote the app description for the app store and settings page's about page
89:19: Completed the layout for about page
90:06: Revised app description.
91:00: Changed project name from PointA to Point A
93:15: Finalized app and archived to get ready for app store submission
94:15: Created Twitter Account for Point A App & Filled out Information for iTunes Connect
* Note: much of the progress in building the initial foundation took place behind the scenes. These pictures are a few of visual snippets I’ve managed to document. If you are interested in the complete log please read: http://tinyurl.com/o78aq8b
From Zero
00:47
Begun the development of the Prototype Application
07:54
Created rudimentary user page
21:34
Begun modeling of groups (Trials and errors… Many hours spent learning)
42:36
Begun modeling Post class
47:20
Created back-end & front-end system for creating new posts in groups
50:01
Added the first file uploader to the group
54:59
Added profile picture avatar & implemented them to show in various views
58:19
Added an audio uploader to the group page
62:44
Implemented file filtering system to view all files in that type (All pictures & All audio)
63:11
Applied basic CSS to streamline filtered files
66:04
Added glyphicons to buttons
67:07
Applied basic CSS to the group side menu
68:03
Added additional CSS to the group side menu and main view
68:29
Implemented sectional scrolling (Screenshot taken retrospectively)
78:51
Created the layout for Group Index view
84:56
Created the layout for Inbox view
85:57
Added the functionality to delete invitations
88:02
Updated group show view button layout & Column width
91:55
Implemented updated version of file uploader (upload button changes color & can be clicked again to discard file)
100:40
Created Welcome & About page & Updated layouts
101:00
Deployed first fully functional web application on the world wide web!
Deployment
Thank you for reading this post!
If you are interested in checking out this site please visit jkim.herokuapp.com
And stay tuned here for more updates about this app! I will be documenting all future updates and overall progress on this blog.
For this week of 100 Hour Challenge I’ve decided to build a social networking site. As a part of last challenge, I’ve completed Ruby on Rails Tutorial by Michael Hartl ( & Unity 2D ) -- and as an extension of the last challenge I’ve built my own web application.
The Prototype Application ( temporary name ) is a group focused content sharing platform built to deliver, store & organize contents you share with people. It is now deployed on temporary URL -- jkim.herokuapp.com -- if you are interested please feel free to use it!
Following this point is a complete log of the progress I’ve made this week.
Day 1
00:01
Beginning by reviewing rails tutorial by Michael Hartl & and the demo application from the last challenge
00:47
Begun the development of the Prototype Application
01:20
First repository on GitHub
01:28
Setup Heroku for production
01:43
First push to Heroku
02:07
First homepage post on localserver
02:30
Additional Review of Rails API
03:20
Added bootstrap
04:00
Added basic style & configured routes
05:20
Added user model & validations
05:48
Added password encryption & related validations
06:50
Precompiled assets for production
07:54
Created rudimentary user page
08:32
Created initial state user signup page
09:41
Completed user signup page
10:01
Added flash notification
11:02
Deployed ground level project to production
12:06
Setup initial state user login page
Day 2
14:30
Completed login functionality & alternate homepage for logged in users
15:17
Wrote login integration test
15:39
Added Logout functionality
16:19
Just learned that you cannot use "test_" in the beginning of test helper methods because it is already being used by Rails
16:58
Fixed compiling error with heroku...
bootstrap was not loading in production environment --
updated rails_12factor gem
& ran
RAILS_ENV=production bundle exec rake assets:precompile
to fix the problem
17:44
Added initial state user account update/settings page
18:40
Added integration test user account update
19:45
Implemented security measures to prevent not logged in users from accessing accounts
20:37
Implemented security measures to prevent wrong users from accessing other accounts
21:00
Designing app structure & model relationships for the next step
21:34
Begun modeling of groups
21:50
Show - shows the group page
New - creates new group
Edit - customize group customization
22:19
Reviewing model relationships
23:21
modeled memberships to bridge two way relationship between users - groups
24:06
Examining model relationship behaviors in rails console (sandbox)
24:30
Shaping Membership & Group model based on findings from examination
26:16
Added page for showing all of user's groups
27:55
Added group creation functionality for users
Day 3
28:25
Begun modeling of group invitations
28:44
Added initial state group show (main) page
29:43
Added validations to prevent users from accessing other groups that they not belong to
32:50
Created back-end system for sending a user group invitation
33:30
Created back-end system for accepting group invitations
35:50
Solving some database mystery... Created sender & recipient but only sender is created correctly & recipient is only created once
37:42
Created initial state front-end system for sending a user group invitation
38:40
Completed system for sending a user group invitation
39:50
Created front-end system for viewing your invitations
41:33
Completed system for accepting invitations
41:58
Added validations to prevent security issues & bugs
Day 4
42:36
Begun modeling Post class
42:54
Learning about image uploading options in Rails
Finished Unity 2D Essential Training by Jesse Freeman
Finished Scripting Unity with C# by Kelley Hecker
Finished Project: 2D Roguelike Tutorial by Unity
Made 1 Demo Web Application
Made 2 Demo Unity Game
Designed & Created Original A.I. System for Unity
Since the beginning of the week I’ve learned -
Fundamental understanding of Ruby On Rails -- How to build a web application from scratch and securely deploy on the world wide web
Fundamental understanding of Unity2D -- How to use Unity’s framework to develop 2D games
Functional knowledge of C# programming language & Unity’s scripting API -- How to create modular A.I. with C# and MonoDevelop
How to create custom 2D sprites and animations with pixel art
Also I’ve learned much about productivity, value of time, and myself... which I will post of blog about soon.
And I’ll continue to log my progress on Web Development, Game Development, and more. If you read this and had any questions feel free to let me know!
-------
Web Development
Day 7
Ruby On Rails Tutorial
-------
41:15
added
micropost feed page
embedded in user page
42:16
made home page into
micropost posting page
for logged in users
42:42
Fully implemented
micropost creation
functionality
&
added micropost feed to
user page
43:05
* added micropost
validation to user page
43:25
added micropost
delete function
43:57
added picture uploader
44:32
* configured
micropost feed to
display resized image
[used CSS instead of
image resizing program]
45:03
Rails Tutorial
Ch. 11 Finished
45:04
The last chapter..!
46:31
learning about
data models linked by
employing
intermediary model
(following -
active & passive relationship -
follower)
47:17
learning about
advanced routing options
47:28
added
follower & following model and stats view
48:35
added
followers & following page
48:52
implemented
fully functional
follow & unfollow function
49:30
implemented
AJAX request for handling
follow & unfollow function
50:11
configured
homepage to show
user & following posts
&
applied rudimentary
SQL optimization for
better scaling
50:15
Created full feature
demo web application
50:27
Finished
Rails Tutorial Ch. 12
-
Finished
The Ruby on Rails Tutorial by Michael Hartl
-------
Game Development
Day 7
Adding Functionality
To Prototype Game
-------
43:35
learned how to set & use
Class properties
44:12
coded parts of first layer
of logic hierarchy
&
sent data to the
next layer
44:48
set up
target acquisition
45:32
reconfigured
unit sizes &
distance calculation
46:30
coded parts of
second and third layer
(action and movement)
&
linked all the layers
together to make all logic
in the hierarchy
conceptually functional
implemented
following logic
(slime)
1) logic
- Territorial
-- 1. no enemy
---- 2) action
------- chill out
---------3) movement
------------ move random
-- 2. enemy in sight
---- 2) action
------- aggression
--------- 1. in range
----------- 3) movement
------------- attack
--------- 2. out of range
----------- 3) movement
------------- move toward
46:48
coded
Movement_MoveTowardsTarget
Class and its functions
47:56
linked Movement Classes
to character animations
48:47
coded
Movement_Random
Class and its functions
49:07
Completed
modular Logic system
(logic-action-movement)